Visão geral do Memcache

Nesta página, você terá uma visão geral do serviço Memcache do App Engine. É comum que, para algumas tarefas, os aplicativos da Web escalonáveis de alto desempenho usem um cache de dados na memória distribuído em frente a, ou no lugar de, um armazenamento permanente robusto. O App Engine inclui um serviço de cache de memória para essa finalidade. Para saber como configurar, monitorar e usar o serviço Memcache, consulte Como usar o Memcache.

Quando usar um cache de memória

Um dos usos de um cache de memória é acelerar consultas comuns no armazenamento de dados. Se muitas solicitações fizerem a mesma consulta com os mesmos parâmetros e as alterações nos resultados não precisarem aparecer no site imediatamente, o aplicativo poderá armazenar os resultados no Memcache. As solicitações subsequentes poderão verificar o Memcache e só executar a consulta no armazenamento de dados se não houver resultados ou se eles tiverem expirado. Os dados da sessão, as preferências do usuário e outros dados retornados por consultas a páginas da Web são bons candidatos para armazenamento em cache.

O Memcache pode ser útil para outros valores temporários. No entanto, para decidir se quer armazenar um valor apenas no Memcache e não em outro armazenamento permanente, verifique se o comportamento do aplicativo é aceitável quando o valor se torna indisponível de repente. Um valor pode expirar no Memcache a qualquer momento, inclusive antes do prazo de expiração definido para ele. Por exemplo, se o funcionamento da sessão for prejudicado pela ausência repentina dos dados de sessão do usuário, provavelmente é melhor armazená-los em outro local além do Memcache.

Níveis de serviço

Dois níveis do serviço Memcache são aceitos pelo App Engine:

  • O Memcache compartilhado é o padrão gratuito dos aplicativos do App Engine. Fornece a capacidade do cache de forma mais eficiente e está sujeito à demanda geral de todos os aplicativos do App Engine que usam o serviço Memcache compartilhado.

  • No Memcache dedicado, a capacidade do cache é fixa e atribuída exclusivamente ao aplicativo. Ele é faturado por GB/hora do tamanho do cache e exige que o faturamento esteja ativado. Ter controle sobre o tamanho do cache significa que o aplicativo pode ter desempenho mais previsível e com menos leituras de um armazenamento durável e mais caro.

Os dois níveis do serviço Memcache usam a mesma API. Para configurar o serviço Memcache para o aplicativo, consulte Como usar o Memcache.

A tabela a seguir contém um resumo das diferenças entre as duas classes do serviço Memcache:

Recurso Memcache dedicado Memcache compartilhado
Preço US$ 0,06 por GB/hora Gratuito
Capacidade
us-central
1 a 100 GB
outras regiões
1 a 20 GB
Sem capacidade garantida
Desempenho Até 10.000 leituras ou 5.000 gravações (exclusivas) por segundo por GB (itens menores que 1 KB). Para mais detalhes, consulte Estatísticas de cache. Não garantido
Armazenamento durável Não Não
SLA Nenhum Nenhum

O faturamento dedicado do Memcache é cobrado em acréscimos de 15 minutos. Se o pagamento for em moeda diferente do dólar americano, serão aplicados os preços listados na página SKUs do Cloud Platform.

Se o aplicativo precisar de mais capacidade de Memcache, entre em contato com nossa equipe de vendas.

Limites

Os limites a seguir se aplicam ao uso do serviço Memcache:

  • O tamanho máximo de um valor de dados em cache é 1 MiB (2^20 bytes), menos o tamanho da chave, menos uma sobrecarga que depende da implementação e é de aproximadamente 73 bytes.
  • Uma chave não pode ter mais de 250 bytes. No ambiente de execução do Java, as chaves que são objetos ou strings com mais de 250 bytes gerarão hash. O comportamento é diferente em outros ambientes de execução.
  • As operações "multi" em lote podem ter qualquer número de elementos. O tamanho total da chamada e dos dados buscados não pode ser superior a 32 megabytes.
  • Uma chave de Memcache não pode conter um byte nulo.

APIs disponíveis

O Memcache do App Engine é compatível com duas interfaces: uma Memcache API de baixo nível e a especificação JCache. As seções a seguir fornecem mais informações sobre cada interface.

API de baixo nível

A Memcache API de baixo nível aceita mais funcionalidades em comparação com o JCache. Alguns exemplos:

  • Aumentar e diminuir atomicamente os valores do contador de inteiros.
  • Expor mais estatísticas de cache, como a quantidade de tempo desde quando a entrada menos usada recentemente foi acessada e o tamanho total de todos os itens no cache.
  • Verificar e definir operações para armazenar dados condicionalmente.
  • Usar AsyncMemcacheService para executar as operações do Memcache de maneira assíncrona.

A API de baixo nível oferece MemcacheService e AsyncMemcacheService para acessar o serviço do Memcache. Essa API é mais abrangente do que a fornecida por JCache.

Consulte Exemplos do Memcache para ver exemplos de uso síncrono e assíncrono da API Memcache de baixo nível.

JCache

O SDK do App Engine para Java é compatível com a API JCache. O JCache tem uma interface para dados armazenados em cache parecida com um mapa. Armazene e recupere valores no cache usando chaves. As chaves e valores podem ser de qualquer tipo ou classe serializável. Para mais detalhes, consulte Como usar o Memcache.

Recursos incompatíveis do JCache

O JCache não é compatível com os seguintes recursos:

  • A API do listener do JCache é parcialmente compatível com listerners executáveis durante o processamento de uma chamada de API de um aplicativo, como no caso dos listeners onPut e onRemove. Listerners que requerem processamento em segundo plano, como onEvict, não são compatíveis.
  • É possível que um aplicativo teste se o cache contém uma determinada chave, mas não que teste se o cache contém um determinado valor (containsValue() não é compatível).
  • Um aplicativo não pode despejar o conteúdo de chaves ou valores do cache.
  • Um aplicativo não pode redefinir manualmente as estatísticas do cache.
  • O método put() não retorna o valor conhecido anterior de uma chave. Ele sempre retorna null.

Como os dados em cache expiram

O Memcache contém pares de chave/valor. Os pares na memória são alterados a qualquer momento, à medida que os itens são gravados e recuperados do cache.

Por padrão, os valores armazenados no Memcache são retidos o máximo possível. Os valores podem ser removidos do cache quando um novo valor é adicionado e o cache está com pouca memória. Quando a remoção ocorre por pressão sobre a memória, são removidos primeiro os valores usados há mais tempo.

O aplicativo pode fornecer um prazo de validade quando um valor é armazenado, como um número de segundos relativo ao momento em que o valor foi adicionado ou como uma horário Unix absoluto no futuro (um número de segundos desde a meia-noite do dia 1º de janeiro de 1970). O valor será removido até esse horário, mas pode ser removido antes por outros motivos. Incrementar o valor armazenado de uma chave existente não atualiza o prazo de validade dela.

Em circunstâncias raras, os valores também podem desaparecer do cache antes da expiração por outros motivos que não a pressão sobre a memória. O Memcache é resiliente em relação a falhas do servidor, mas os valores não são salvos no disco. Portanto, uma falha no serviço pode fazer com que eles fiquem indisponíveis.

Em geral, um aplicativo não espera que um valor armazenado em cache esteja sempre disponível.

É possível apagar todo o cache de um aplicativo por meio da API ou na seção do Memcache do Console do Google Cloud.

Estatísticas do cache

Operações por segundo por tamanho do item

O Memcache dedicado é taxado em operações por segundo por GB, em que uma operação é definida como um acesso a itens de cache individuais, como get, set ou delete. A taxa de operação varia conforme o tamanho do item, mais ou menos de acordo com a tabela a seguir. Exceder essas taxas talvez resulte aumento da latência ou erros da API.

As tabelas a seguir mostram o número máximo de operações get-hit ou set sustentadas e exclusivas por GB de cache. Observe que uma operação get-hit é uma chamada get que descobre que há um valor armazenado com a chave especificada e retorna esse valor.

Tamanho do item (KB) Máximo de operações get-hit/s Máximo de operações set/s
≤ 1 10.000 5.000
100 2.000 1.000
512 500 250

Um aplicativo configurado para vários GB de cache pode, teoricamente, alcançar uma taxa de operação agregada calculada como o número de GB multiplicado pela taxa por GB. Por exemplo, um aplicativo configurado para 5 GB de cache pode atingir 50.000 operações do Memcache por segundo em itens de 1 KB. Alcançar esse nível requer uma boa distribuição de carga no keyspace do Memcache.

Para cada padrão de E/S, os limites listados acima são para leituras ou gravações. Para leituras e gravações simultâneas, os limites estão em uma escala móvel. Quanto mais leituras forem feitas, menos gravações poderão ser feitas e vice-versa. Abaixo, veja exemplos de limites de IOPs para leituras e gravações simultâneas de valores de 1 KB por GB de cache:

IOPs de leitura IOPs de gravação
10.000 0
8.000 1.000
5.000 2.500
1.000 4.500
0 5.000

Unidades de computação do Memcache (MCU)

A capacidade de transferência do Memcache pode variar conforme o tamanho do item que você acessa e a operação a ser executada nele. É possível associar um custo aproximado às operações e estime a capacidade de tráfego que você pode esperar do Memcache dedicado usando uma unidade denominada Unidade de computação do Memcache (MCU, na sigla em inglês). A MCU é definida de modo a esperar 10.000 MCU por segundo por GB de Memcache dedicado. O Console do Google Cloud mostra a quantidade de MCU que seu aplicativo está usando no momento.

Observe que a MCU é uma estimativa estatística aproximada. Além disso, não é uma unidade linear. Cada operação de cache que lê ou grava um valor tem um custo de MCU correspondente que depende do tamanho do valor. A MCU de um set depende do tamanho do valor: é duas vezes o custo de uma operação get-hit bem-sucedida.

Tamanho do item de valor (KB) Custo de MCU para get-hit Custo de 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

Operações que não leem ou gravam um valor têm custo MCU fixo:

Operação MCU
get-miss 1,0
delete 2,0
increment 2,0
flush 100,0
stats 100,0

Observe que uma operação get-miss é um get que descobre que não há um valor armazenado com a chave especificada.

Práticas recomendadas

Seguem algumas práticas recomendadas para o uso do Memcache:

  • Gerencie normalmente as falhas da API Memcache. As operações do Memcache podem falhar por vários motivos. Os aplicativos precisam ser projetados para capturar operações com falha sem expor esses erros aos usuários finais. Essa orientação se aplica especialmente às operações Set.

  • Use a capacidade de lote da API sempre que possível, especialmente para itens pequenos. Isso melhora o desempenho e a eficiência do aplicativo.

  • Distribua a carga no keyspace do Memcache. Ter um só item ou um pequeno grupo de itens do Memcache representando um volume de tráfego desproporcional impedirá o dimensionamento do aplicativo. Essa orientação se aplica tanto às operações por segundo quanto à largura de banda. Muitas vezes, a fragmentação explícita dos dados pode diminuir o problema.

    Por exemplo, é possível dividir um contador atualizado frequentemente entre várias chaves, lendo-as e somando-as apenas quando um total for necessário. Da mesma forma, é possível dividir 500.000 partes de dados que precisem ser lidas em todas as solicitações HTTP em várias chaves e fazer a leitura usando uma única chamada da API em lote. Melhor ainda seria armazenar o valor em cache na memória da instância. Para o Memcache dedicado, a taxa de acesso de pico em uma única chave precisa ser de uma a duas ordens de magnitude menor do que a taxa por GB.

A seguir