Como acessar o cache no Node.js

Você está vendo a documentação do Apigee Edge.
Acesse a documentação da Apigee X. info

É possível usar o módulo apigee-access para acessar o cache distribuído do Edge em um aplicativo Node.js. O módulo inclui métodos para pegar um cache e colocar, pegar e remover dados.

O cache distribuído do Apigee Edge permite armazenar strings ou outros dados. Como a maioria dos caches, ele é um cache usado menos recentemente com um tamanho máximo. No Apigee Edge, o cache é distribuído entre todos os nós em que o aplicativo Node.js é executado. É possível gerenciar o cache por meio de uma API Apigee Edge. Com a API, é possível criar recursos de cache manualmente ou usar o recurso padrão. Para uma introdução ao armazenamento em cache no Apigee Edge, consulte Ferramentas de persistência no Edge. Para saber mais sobre o cache distribuído, consulte Exemplo: armazenamento em cache de uso geral.

Para uma introdução ao módulo apigee-access e outros recursos, consulte Como usar o módulo apigee-access.

Métodos

(1) getCache

var cache = apigee.getCache(cacheName);

Procure um cache nomeado e crie-o, se necessário. O cache resultante usa um conjunto predefinido de parâmetros de configuração adequados para a maioria das situações.

Parâmetros:

cacheName: uma string, o nome do cache. Não é o nome do recurso de cache.

Retorna:

Um objeto de cache.

Exemplo:

var apigee = require('apigee-access');
var cache = apigee.getCache('cache');

(2) getCache

var customCache = apigee.getCache(cacheName, options );

Acesse um recurso de cache personalizado especificado em um objeto de configuração. Para informações sobre como criar um recurso de cache, consulte Como criar e editar um cache de ambiente.

Parâmetros:

cacheName: uma string, o nome do cache personalizado. Não é o nome do recurso de cache.

options: um objeto de configuração. O objeto pode estar vazio ou conter os seguintes parâmetros opcionais:

  • resource: o nome de um "recurso de cache" da Apigee em que os dados de cache são armazenados. Os recursos de cache são usados para ajustar a alocação de memória e outros parâmetros de cache. Se não for especificado, um recurso padrão será usado. Se o recurso de cache não existir, o método vai gerar um erro.

  • scope: especifica se as entradas de cache têm prefixo para evitar colisões. Os valores válidos são global, application e exclusive.

    • global: todas as entradas de cache podem ser vistas por todos os aplicativos Node.js no mesmo "ambiente" da Apigee.

    • application: todas as entradas de cache podem ser vistas por todos os caches do Node.js que fazem parte do mesmo aplicativo do Apigee Edge.

    • exclusive: (padrão) As entradas de cache são vistas apenas pelos caches do Node.js no mesmo aplicativo e com o mesmo nome. Esse é o padrão.

  • prefix: se o nome da chave de cache incluir um prefixo, conforme descrito em Política de preenchimento de cache e Como trabalhar com chaves de cache, use este parâmetro para especificar. O Edge adiciona automaticamente um sufixo de dois sublinhados ao nome do prefixo. Portanto, se uma chave de cache foi criada com o prefixo "UserToken", o prefixo a ser especificado aqui é "UserToken__".

  • defaultTtl: especifica o time to live (TTL) padrão de uma entrada de cache, em segundos. Se não for especificado, o TTL padrão no recurso de cache será usado.

  • timeout: o tempo de espera para buscar um resultado do cache distribuído, em segundos. O padrão é 30 segundos. Os aplicativos sensíveis à latência podem querer reduzir isso para evitar tempos de resposta lentos se a infraestrutura de cache estiver sobrecarregada.

Retorna:

Um objeto de cache personalizado.

Exemplo:

var apigee = require('apigee-access');
var customCache = apigee.getCache('doesNotMatter',
  { resource: 'MyCustomResource', scope: 'global', prefix: 'UserToken'} );
customCache.put("myCacheKey", "xyz");

Isso funciona com uma política LookupCache configurada desta forma:

<LookupCache name="Lookup-Cache-1">
  <CacheKey>
    <Prefix>UserToken</prefix>    
    <KeyFragment>myCacheKey</KeyFragment>
  </CacheKey>
  <CacheResource>MyCustomResource</CacheResource>
  <Scope>Global</Scope>
  <AssignTo>contextVariable</AssignTo>
</LookupCache>

put

cache.put('key', data, ttl, function(error));

Coloque dados em um cache.

Parâmetros:

  • key: (obrigatório) uma string que identifica exclusivamente o item no cache. As chaves de cache são limitadas a um tamanho de 2 KB.

  • data: (obrigatório) uma string, um buffer ou um objeto que representa os dados a serem armazenados em cache. Qualquer outro tipo de dados vai resultar em um erro. Por conveniência, os objetos serão convertidos em uma string usando "JSON.stringify".

  • ttl: (opcional) o tempo máximo para manter os dados no cache, em segundos. Se não for especificado, um TTL padrão será usado.

  • callback (opcional): se especificada, uma função que será chamada quando os dados estiverem com segurança no cache. Ele será chamado com um objeto Error como o primeiro parâmetro se houver um erro de inserção. Caso contrário, ele será chamado sem parâmetros.

Exemplo:

var apigee = require('apigee-access');
var cache = apigee.getCache();
// Insert a string into cache using the default TTL
cache.put('key1', 'Buenos dias, Mundo!');
// Insert a string into cache using a TTL of 120 seconds
cache.put('key2', 'Hello, World!', 120);
// Insert a string with the default TTL, and get notified when the insert is complete
cache.put('key3', 'Ciao, Mondo!', function(error) {
  // "error" will be falsy unless there was an error on insert
});
// Insert a string with a TTL of 600 seconds, and get notified when the insert is complete
cache.put('key4', 'Hallo Wereld!', 600, function(error) {
  // "error" will be falsy unless there was an error on insert
});

receber

cache.get('key', function(error, data));

Recuperar dados de um cache.

Parâmetros:

  • key (obrigatório): uma string que identifica exclusivamente o item no cache.

    Para entradas de cache inseridas em uma política do Apigee Edge (como a política Preencher cache), você vai precisar construir a chave de cache inferindo a maneira específica como a política cria chaves para entradas. Para isso, você precisa saber como a política está configurada. Embora o artigo Trabalhar com chaves de cache descreva como as chaves de cache são criadas por políticas, não especifique valores de string relacionados ao escopo. Nas chamadas do Node.js, o escopo já faz parte do contexto.

  • callback (obrigatório): uma função que será chamada quando os dados estiverem disponíveis. Se houver dados em cache, eles serão retornados no segundo parâmetro.

    • error: um objeto de erro. Se houver um erro ao recuperar do cache, um objeto Error será definido aqui. Caso contrário, esse parâmetro será definido como "undefined".

    • data: os dados recuperados, se houver. Será um destes valores:

      • Se uma string foi inserida, ela será uma string.
      • Se um buffer foi inserido, ele será um buffer.
      • Se um objeto foi inserido, ele será uma string que contém a versão JSON do objeto, conforme produzido por "JSON.stringify".
      • Se nada for encontrado, o valor será "indefinido".

Exemplo:

var apigee = require('apigee-access');
var cache = apigee.getCache();
cache.get('key', function(error, data) {
  // If there was an error, then "error" will be set.
  // If error is falsy, "data" is the item that was retrieved:
  //   - undefined, in the case of cache miss, or
  //   - a Buffer, or
  //   - a String
});

remove

cache.remove('key', function(error));

Invalidar um item armazenado em cache. Quando uma chave é invalidada, as solicitações get() subsequentes retornam "undefined", a menos que outro valor seja inserido.

Parâmetros:

  • key (obrigatório): uma string que identifica de forma exclusiva o item no cache a ser invalidado.

    Para entradas de cache colocadas em cache a partir de uma política do Apigee Edge (como Preencher política de cache), você precisará construir a chave de cache inferindo a maneira específica como a política cria chaves para entradas. Para fazer isso, você precisa saber como a política está configurada. Embora o artigo Trabalhar com chaves de cache descreva como as chaves de cache são criadas por políticas, não especifique valores de string relacionados ao escopo. Nas chamadas do Node.js, o escopo já faz parte do contexto.

  • callback (obrigatório): uma função de callback que será chamada com um objeto Error como o primeiro parâmetro em caso de erro.

Exemplo:

var apigee = require('apigee-access');
var cache = apigee.getCache();
cache.remove('key', function(error) {
});