Esta página oferece uma vista geral do serviço de cache de memória do App Engine. As aplicações Web escaláveis de alto desempenho usam frequentemente uma cache de dados na memória distribuída antes ou em vez de um armazenamento persistente robusto para algumas tarefas. O App Engine inclui um serviço de cache de memória para este fim. Para saber como configurar, monitorizar e usar o serviço memcache, leia o artigo Usar o memcache.
Quando usar uma cache de memória
Uma utilização de uma cache de memória é acelerar as consultas comuns da base de dados. Se muitos pedidos fizerem a mesma consulta com os mesmos parâmetros e as alterações aos resultados não precisarem de aparecer imediatamente no Website, a aplicação pode colocar os resultados em cache na memcache. Os pedidos subsequentes podem verificar a memcache e só executar a consulta da base de dados se os resultados estiverem ausentes ou expirados. Os dados de sessões, as preferências do utilizador e outros dados devolvidos por consultas de páginas Web são bons candidatos para o armazenamento em cache.
O Memcache pode ser útil para outros valores temporários. No entanto, ao considerar se deve armazenar um valor apenas na memcache e não suportado por outro armazenamento persistente, certifique-se de que a sua aplicação tem um comportamento aceitável quando o valor deixa de estar disponível repentinamente. Os valores podem expirar da memória cache em qualquer altura e podem expirar antes do prazo de validade definido para o valor. Por exemplo, se a ausência súbita dos dados de sessão de um utilizador fizer com que a sessão funcione incorretamente, esses dados devem provavelmente ser armazenados no arquivo de dados, além da cache de memória.
Níveis de serviço
O App Engine suporta dois níveis do serviço de cache de memória:
A memcache partilhada é a predefinição gratuita para aplicações do App Engine. Oferece capacidade de cache com base no melhor esforço possível e está sujeita à procura geral de todas as aplicações do App Engine que usam o serviço memcache partilhado.
A memcache dedicada oferece uma capacidade de cache fixa atribuída exclusivamente à sua aplicação. É faturado por GB/hora de tamanho da cache e requer a ativação da faturação. Ter controlo sobre o tamanho da cache significa que a sua app pode ter um desempenho mais previsível e com menos leituras do armazenamento duradouro mais dispendioso.
Ambos os níveis de serviço de memcache usam a mesma API. Para configurar o serviço memcache para a sua aplicação, consulte o artigo Usar o Memcache.
A tabela seguinte resume as diferenças entre as duas classes do serviço de memcache:
| Funcionalidade | Memcache dedicado | cache de memória partilhada |
|---|---|---|
| Preço | 0,06 $ por GB por hora | Grátis |
| Capacidade |
|
Sem capacidade garantida |
| Desempenho | Até 10 mil leituras ou 5 mil escritas (exclusivas) por segundo por GB (itens < 1 KB). Para mais detalhes, consulte o artigo Estatísticas da cache. | Não garantido |
| Loja duradoura | Não | Não |
| SLA | Nenhum | Nenhum |
A faturação da memcache dedicada é cobrada em incrementos de 15 minutos. Se pagar numa moeda que não seja USD, são aplicados os preços na moeda indicada nos SKUs da Cloud Platform.
Se a sua app precisar de mais capacidade de memcache, contacte a nossa equipa de vendas.
Limites
Os seguintes limites aplicam-se à utilização do serviço memcache:
- O tamanho máximo de um valor de dados em cache é de 1 MiB (2^20 bytes) menos o tamanho da chave menos uma sobrecarga dependente da implementação, que é de aproximadamente 73 bytes.
- Uma chave não pode ter mais de 250 bytes.
- As operações em lote "multi" podem ter qualquer número de elementos. O tamanho total do pedido e o tamanho total dos dados obtidos não podem exceder 32 megabytes.
- Uma chave de memcache não pode conter um byte nulo.
- A utilização da API Memcache de nível partilhado está sujeita a limites definidos por Unidades de computação de centi Memcache partilhadas por região por minuto.
Recomendações e práticas recomendadas
Quando usar o Memcache, recomendamos que crie as suas aplicações para:
Trate o caso em que um valor em cache nem sempre está disponível.
- O Memcache não é um armazenamento duradouro. De acordo com a política de despejo, as chaves são despejadas quando a cache fica cheia. As alterações na configuração da cache ou os eventos de manutenção do centro de dados também podem limpar parte ou toda a cache.
- O Memcache pode sofrer indisponibilidade temporária. As operações de Memcache podem falhar por vários motivos, incluindo alterações na configuração da cache ou eventos de manutenção do centro de dados. As aplicações devem ser concebidas para detetar operações com falhas sem expor estes erros aos utilizadores finais. Estas orientações aplicam-se especialmente às operações de conjunto.
Use a capacidade de processamento em lote da API sempre que possível.
- Ao fazê-lo, aumenta o desempenho e a eficiência da sua app, especialmente para artigos pequenos.
Distribua a carga pelo seu espaço de chaves de memcache.
Ter um único ou um pequeno conjunto de itens de memcache que representam uma quantidade desproporcionada de tráfego impede o dimensionamento da sua app. Estas orientações aplicam-se a operações/segundo e largura de banda. Pode muitas vezes aliviar este problema dividindo explicitamente os seus dados.
Por exemplo, pode dividir um contador atualizado com frequência entre várias chaves, lendo-as e somando-as apenas quando precisar de um total. Da mesma forma, pode dividir um conjunto de dados de 500 mil elementos que tem de ser lido em cada pedido HTTP em várias chaves e lê-los novamente através de uma única chamada API em lote. (Ainda melhor seria colocar o valor em cache na memória da instância.) Para a memcache dedicada, a taxa de acesso máxima numa única chave deve ser 1 a 2 ordens de magnitude inferior à classificação por GB.
Mantenha as suas próprias chaves para obter valores da cache.
- O Memcache não fornece um método para listar chaves. Devido à natureza da cache, não é possível listar chaves sem interromper a cache. Além disso, alguns idiomas, como o Python, aplicam hash a chaves longas, e as chaves originais só são conhecidas pela aplicação.
Como os dados em cache expiram
A Memcache contém pares de chave/valor. Os pares na memória em qualquer altura mudam à medida que os itens são escritos e obtidos a partir da cache.
Por predefinição, os valores armazenados na memcache são retidos o máximo possível. Os valores podem ser removidos da cache quando é adicionado um novo valor à cache e a cache tem pouca memória. Quando os valores são removidos devido à pressão da memória, os valores usados com menos frequência são removidos primeiro.
A app pode fornecer um prazo de validade quando um valor é armazenado, como um número de segundos relativo ao momento em que o valor é adicionado ou como um tempo de época Unix absoluto no futuro (um número de segundos a partir da meia-noite de 1 de janeiro de 1970). O valor é removido o mais tardar a esta hora, embora possa ser removido antes por outros motivos. Incrementar o valor armazenado para uma chave existente não atualiza o respetivo tempo de expiração.
Em circunstâncias raras, os valores também podem desaparecer da cache antes da expiração por motivos que não sejam a pressão na memória. Embora a memcache seja resiliente a falhas do servidor, os valores da memcache não são guardados no disco, pelo que uma falha do serviço pode fazer com que os valores fiquem indisponíveis.
Em geral, uma aplicação não deve esperar que um valor em cache esteja sempre disponível.
Pode apagar a cache completa de uma aplicação através da API ou na secção de memcache da consola Google Cloud .
Estatísticas da cache
Operações por segundo por tamanho do artigo
A memcache dedicada é classificada em operações por segundo por GB, em que uma operação é definida como um acesso individual a um item da cache, como get, set ou delete. A taxa de operação varia consoante o tamanho do artigo, aproximadamente, de acordo com a tabela seguinte. Exceder estas classificações pode resultar num aumento da latência da API ou em erros.
As tabelas seguintes indicam o número máximo de operações sustentadas, exclusivas
get-hit ou set por GB de cache. Tenha em atenção que uma operação get-hit é uma chamada get que determina que existe um valor armazenado com a chave especificada e devolve esse valor.
| Tamanho do item (KB) | Máximo de get-hit operações/s |
Máximo de set operações/s |
|---|---|---|
| ≤1 | 10 000 | 5000 |
| 100 | 2000 | 1000 |
| 512 | 500 | 250 |
Em teoria, uma app configurada para vários GB de cache pode atingir uma taxa de operações agregada calculada como o número de GB multiplicado pela taxa por GB. Por exemplo, uma app configurada para 5 GB de cache pode atingir 50 000 operações de memcache/segundo em itens de 1 KB. Para alcançar este nível, é necessária uma boa distribuição da carga no espaço de chaves da cache de memória.
Para cada padrão de E/S, os limites indicados acima são para leituras ou gravações. Para leituras e escritas simultâneas, os limites estão numa escala deslizante. Quanto mais leituras forem realizadas, menos escritas podem ser realizadas e vice-versa. Seguem-se exemplos de limites de IOPs para leituras e escritas simultâneas de valores de 1 KB por 1 GB de cache:
| IOPS de leitura | IOPS de escrita |
|---|---|
| 10000 | 0 |
| 8000 | 1000 |
| 5000 | 2500 |
| 1000 | 4500 |
| 0 | 5000 |
Unidades de computação da cache de memória (MCU)
O débito do Memcache pode variar consoante o tamanho do item ao qual está a aceder e a operação que quer realizar no item. Pode associar aproximadamente um custo às operações e estimar a capacidade de tráfego que pode esperar da cache de memória dedicada através de uma unidade denominada unidade de computação da cache de memória (MCU). A MCU é definida de forma que possa esperar 10 000 MCUs por segundo por GB de memcache dedicado. A Google Cloud consola mostra a quantidade de MCU que a sua app está a usar atualmente.
Tenha em atenção que a MCU é uma estimativa estatística aproximada e também não é uma unidade linear. Cada operação de cache que lê ou escreve um valor tem um custo de MCU correspondente que depende do tamanho do valor. O MCU para um set depende do tamanho do valor: é 2 vezes o custo de uma operação get-hit bem-sucedida.
| Tamanho do item de valor (KB) | Custo da MCU para get-hit |
Custo da MCU para 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 |
As operações que não leem nem escrevem um valor têm um custo de MCU fixo:
| Operação | MCU |
|---|---|
get-miss |
1,0 |
delete |
2,0 |
increment |
2,0 |
flush |
100,0 |
stats |
100,0 |
Tenha em atenção que uma operação get-miss é uma operação get que determina que não existe nenhum valor armazenado com a chave especificada.
O que se segue?
- Saiba como configurar, monitorizar e usar o memcache em Usar o memcache.