API Memcache per servizi legacy in bundle

Questa pagina fornisce una panoramica del servizio memcache di App Engine. Per alcune attività le applicazioni web scalabili ad alte prestazioni spesso utilizzano una cache di dati in memoria distribuita prima o al posto di una solida archiviazione permanente. A questo scopo, App Engine include un servizio di cache della memoria. Per informazioni su come configurare, monitorare e utilizzare il servizio memcache, consulta l'articolo Utilizzo di memcache.

Quando utilizzare una cache in memoria

Un uso della 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 apparire immediatamente sul sito web, l'applicazione può memorizzare nella cache i risultati in memcache. Le richieste successive possono controllare memcache ed eseguire la query sul datastore solo se i risultati sono assenti o scaduti. I dati della sessione, le preferenze degli utenti 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 su un altro spazio di archiviazione permanente, assicurati che la tua applicazione 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'improvvisa assenza dei dati delle sessioni di un utente causa il malfunzionamento della sessione, è probabile che i dati vengano archiviati anche 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 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 ai GB/ora di dimensioni della cache e richiede l'abilitazione della fatturazione. Avere il controllo delle dimensioni della cache significa che l'app può offrire prestazioni più prevedibili e con meno letture da uno spazio di archiviazione più costoso e durevole.

Entrambi i livelli di servizio memcache utilizzano la stessa API. Per configurare il servizio memcache per la tua applicazione, consulta Utilizzo di memcache.

La seguente tabella riassume le differenze tra le due classi del servizio memcache:

Selezione delle 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
in altre regioni:
Da 1 a 2 GB
 Nessuna capacità garantita
Prestazioni Fino a 10.000 letture o 5.000 scritture (esclusive) al secondo per GB (elementi < 1 kB). Per ulteriori dettagli, consulta l'articolo Statistiche relative alla cache. Non garantito
Negozio durevole No No
SLA Nessuna Nessuna

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 richiede una maggiore capacità memcache, contatta il nostro team di vendita.

Limiti

All'uso del servizio memcache si applicano i limiti seguenti:

  • La dimensione massima di un valore di dati memorizzati nella cache è 1 MiB (2^20 byte) meno la dimensione della chiave meno un overhead dipendente dall'implementazione, che corrisponde a 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 i 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 da:

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

    • Memcache non è un'archiviazione durevole. In base ai criteri di rimozione, le chiavi vengono rimosse quando la cache si riempie. Le modifiche alla configurazione della cache o agli eventi di manutenzione del data center possono anche svuotare tutta o parte della cache.
    • Memcache potrebbe riscontrare una 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 dell'API.

    • Ciò consente di migliorare le prestazioni e l'efficienza della tua app, in particolare per gli oggetti di piccole dimensioni.

  • Distribuisci il carico sullo spazio delle chiavi memcache.

    • Un insieme singolo o ridotto di elementi memcache rappresenta una quantità sproporzionata di traffico ostacola la scalabilità dell'app. Queste indicazioni si applicano sia a operazioni/sec che a larghezza di banda. Spesso puoi attenuare questo problema eseguendo esplicitamente lo sharding dei dati.

      Ad esempio, puoi suddividere un contatore aggiornato di frequente tra diverse chiavi, leggendole e sommandole solo quando ne hai bisogno. Allo stesso modo, puoi suddividere un insieme di 500.000 dati che devono essere letti su ogni richiesta HTTP su più chiavi e rileggerli utilizzando una singola chiamata API batch. Ancora meglio sarebbe memorizzare nella cache il valore dell'istanza. Per memcache dedicata, il tasso di accesso di picco su 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 causarne l'interruzione. Inoltre, alcuni linguaggi, come Python, chiavi hash long e le chiavi originali, sono noti solo all'applicazione.

Implementazione memcache PHP

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

Funzioni con interruzioni nell'API Memcache

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

Funzioni con interruzioni nell'API Memcached

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

Esempio di utilizzo dell'API Memcache PHP in App Engine:

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

Esempio di utilizzo dell'API PHP Memcached 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 per il tempo massimo possibile. I valori possono essere rimossi dalla cache quando ne viene aggiunto un nuovo e se la memoria interna è insufficiente. Quando i valori vengono rimossi 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 a quando viene aggiunto il valore o come un'epoca di Unix assoluta nel futuro (un numero di secondi a partire dalla mezzanotte del 1° gennaio 1970). Il valore viene rimosso non più tardi di questa data/ora, ma può essere rimosso prima per altri motivi. L'aumento del valore archiviato per una chiave esistente non ne aggiorna la data e l'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 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 relative alla cache

Operazioni al secondo per dimensioni dell'elemento

La memcache dedicata ha un numero di operazioni al secondo per GB, dove un'operazione viene 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 secondo la 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, 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 lo restituisce.

Dimensioni elemento (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 operativa aggregata calcolata moltiplicando il numero di GB per la tariffa 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 è necessario una buona distribuzione del carico nello spazio delle chiavi memcache.

Per ogni pattern IO, i limiti elencati sopra si riferiscono alle letture o alle scritture. Per le letture e le scritture simultanee, i limiti sono su scala variabile. Maggiore è il numero di letture eseguite, minore è possibile eseguire operazioni di lettura 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:

IOPS di lettura 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 stai accedendo e dell'operazione che vuoi eseguire. Puoi associare approssimativamente un costo alle operazioni e stimare la capacità di traffico che puoi aspettarti da una memcache dedicata utilizzando un'unità denominata Memcache Compute Unit (MCU). La MCU è definita in modo da prevedere 10.000 MCU al secondo per GB di memcache dedicata. La console Google Cloud mostra la quantità di MCU attualmente utilizzata dalla tua app.

Tieni presente che MCU è una stima statistica approssimativa e non è un'unità lineare. Ogni operazione di cache che legge o scrive un valore ha un costo della 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.

Dimensione 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 fisso dell'MCU:

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 esiste alcun valore archiviato con la chiave specificata.

Passaggi successivi