Como acessar o cache no Node.js

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

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

O cache distribuído do Apigee Edge permite que você armazene strings ou outros dados. Como a maioria dos caches, ele é um cache usado recentemente com um tamanho máximo. Dentro do Apigee Edge, o cache é distribuído entre todos os nós em que seu aplicativo Node.js é executado. É possível gerenciar o cache por meio de uma API Apigee Edge. Com a API, você pode 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 a outros recursos dele, 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 );

Acessar 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 emitirá um erro.

  • scope: especifica se as entradas de cache são prefixadas 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 da Apigee Edge.

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

  • prefix: se o nome da chave de cache incluir um prefixo, conforme descrito em Preencher a política de cache e Como trabalhar com chaves de cache, use esse parâmetro para especificar. O Edge adiciona automaticamente um sufixo sublinhado duplo 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, em segundos, o tempo de vida padrão de uma entrada de cache. Se não for especificado, o TTL padrão no recurso de cache será usado.

  • timeout: tempo em segundos para buscar um resultado do cache distribuído. Os 30 segundos padrão. Aplicativos sensíveis à latência podem reduzir esse problema para evitar tempos de resposta lentos se a infraestrutura do 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>

colocar

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

Colocar os 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 dado vai resultar em erro. Por conveniência, os objetos sã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 especificado, uma função que será chamada quando os dados estiverem no cache com segurança. Se houver um erro de inserção, ele será chamado com um objeto Error como o primeiro parâmetro. 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
});

acessar

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 colocadas no cache de uma política do Apigee Edge (como Preencher a política de cache), você precisará criar a chave de cache inferindo da maneira específica que a política cria chaves para entradas. Para fazer isso, você precisa saber como a política está configurada. A página Como trabalhar com chaves de cache descreve como as chaves de cache são criadas por políticas. No entanto, não se esqueça de que 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 armazenados 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, o parâmetro é definido como "indefinido".

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

      • Se uma string foi inserida, ela será uma string.
      • Se um Buffer foi inserido, ele será um Buffer.
      • Se um objeto tiver sido inserido, ele será uma string contendo a versão JSON do objeto, conforme produzido por "JSON.stringify".
      • Se nada for encontrado, estará "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
});

remover

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

Invalidar um item armazenado em cache. Depois que 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 exclusivamente o item no cache a ser invalidado.

    Para entradas de cache colocadas no cache de uma política do Apigee Edge (como Preencher a política de cache), você precisará criar a chave de cache inferindo da maneira específica que a política cria chaves para entradas. Para fazer isso, você precisa saber como a política está configurada. A página Como trabalhar com chaves de cache descreve como as chaves de cache são criadas por políticas. No entanto, não se esqueça de que 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 se houver um erro.

Exemplo:

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