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.

Ambos os níveis de serviço do 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
Nenhuma 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

A cobrança do Memcache dedicado é feita em incrementos de 15 minutos. Se você fizer pagamentos em uma moeda que não seja o dólar americano, serão aplicados os preços na sua moeda 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 seguintes limites se aplicam ao uso do serviço Memcache:

  • O tamanho máximo de um valor de dados armazenado em cache é de 1 MB (10^6 bytes).
  • Uma chave não pode ter mais que 250 bytes. No ambiente de execução do Python, as chaves que são strings com mais de 250 bytes são codificadas em hash. O comportamento é diferente em outros ambientes de execução.
  • As operações de vários lotes 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.

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 expiração 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 seu tempo de expiração 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 deve esperar que um valor armazenado em cache esteja sempre disponível.

Apague o cache inteiro de um aplicativo por meio da API ou na seção “Memcache” do console do Google Cloud Platform.

Estatísticas do cache

Operações por segundo por tamanho do item

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

As tabelas a seguir contém o número máximo de operações sustentadas e exclusivas de get-hit ou set 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 por segundo Máximo de operações set por segundo
≤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, conforme descrito em Práticas recomendadas para o Memcache do App Engine.

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 forma que você possa esperar 10.000 MCU por segundo por GB de Memcache dedicado. A quantidade de MCU que o aplicativo está usando no momento é exibida no console do Google Cloud Platform.

Observe que a MCU é uma estimativa estatística aproximada, e 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 MCU de get-hit Custo MCU de 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 não haver nenhum valor armazenado com a chave especificada.

Comparar e definir

Comparar e definir é um recurso que permite que várias solicitações processadas simultaneamente atualizem o valor da mesma chave de Memcache atomicamente, evitando disputas.

Principais componentes lógicos de comparar e definir

Se estiver atualizando o valor de uma chave do Memcache que possa receber outras solicitações de gravação simultâneas, você precisará usar o objeto Client do Memcache, que armazena determinadas informações de estado usadas pelos métodos que dão suporte à operação de comparar e definir. Não é possível usar as funções do Memcache get() ou set(), porque elas são sem estado. A classe Client propriamente dita não é segura para uso em linhas de execução. Por isso, você não deve usar o mesmo objeto Client em mais de uma linha de execução.

Ao recuperar chaves, você precisa usar os métodos Client de memcache compatíveis com comparar e definir: gets() ou get_multi() com o parâmetro for_cas definido como True.

Ao atualizar uma chave, você precisa usar os métodos Client de memcache compatíveis com comparar e definir: cas() ou cas_multi().

O outro componente-chave lógico é o serviço Memcache do App Engine e o comportamento dele em relação a comparar e definir. O serviço Memcache do App Engine se comporta de maneira atômica. Ou seja, quando duas solicitações simultâneas (para o mesmo código do app) usam o mesmo Memcache, elas vão para a mesma instância do serviço Memcache e o serviço Memcache fica com bloqueio interno suficiente para que solicitações simultâneas da mesma chave sejam devidamente serializadas. Em especial, isso significa que duas solicitações cas() para a mesma chave não são executadas efetivamente em paralelo. O serviço processa a primeira solicitação que chegou até a conclusão (ou seja, atualizando o valor e o carimbo de data/hora) antes de começar a processar a segunda solicitação.

Para aprender a usar comparar e definir no Python, leia Como processar gravações simultâneas.

Práticas recomendadas

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

  • Gerencie normalmente as falhas da API do 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 de uma única chave precisa ser uma a duas ordens de magnitude menor do que a classificação por GB.

Para mais detalhes e práticas recomendadas de simultaneidade, desempenho e migração, incluindo o compartilhamento de Memcache entre diferentes linguagens de programação, leia o artigo Práticas recomendadas para o Memcache do App Engine.

Próximas etapas

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Ambiente padrão do App Engine para Python 2