Cette page a été traduite par l'API Cloud Translation.

Accéder au cache dans Node.js

Vous consultez la documentation d'Apigee Edge.
Accédez à la documentation sur Apigee X. info

Avis d'abandon du Private Cloud :

Compatibilité avec les mandataires Node.js et les coffres sécurisés

Depuis 2013, Apigee prend en charge l'utilisation des proxys Node.js dans Apigee Edge via l'utilisation de Trireme, qui vous permet d'exécuter votre code Node.js dans Apigee Edge pour Private Cloud et de l'exposer en tant qu'API.

Apigee recommande aux clients Private Cloud de suivre les étapes ci-dessous:

Migrez les données de coffres sécurisés vers des mappages clé-valeur chiffrés (KVM) pour accéder aux données sensibles à partir d'un proxy d'API.
Migrez les proxys d'API basés sur Trireme (Node.js) vers un environnement Node.js natif en dehors d'Apigee.

Consultez également la page Abandons et abandons d'Apigee.

Vous pouvez utiliser le module apigee-access pour accéder au cache distribué Edge à partir d'une application Node.js. Le module inclut des méthodes permettant d'obtenir un cache et de mettre, obtenir et supprimer des données.

Le cache distribué Apigee Edge vous permet de stocker des chaînes ou d'autres données. Comme la plupart des caches, il s'agit d'un cache de la moins récente utilisation avec une taille maximale. Dans Apigee Edge, le cache est réparti entre tous les nœuds sur lesquels votre application Node.js s'exécute. Vous pouvez gérer le cache via une API Apigee Edge. À l'aide de l'API, vous pouvez créer manuellement des ressources de cache ou utiliser la ressource par défaut. Pour en savoir plus sur le cache dans Apigee Edge, consultez la section Outils de persistance dans Edge. Pour en savoir plus sur le cache distribué, consultez Exemple: Mise en cache à usage général.

Pour obtenir une présentation du module apigee-access et de ses autres fonctionnalités, consultez Utiliser le module apigee-access.

Méthodes

(1) getCache
(2) getCache.
put
get
supprimer

(1) getCache

var
  cache = apigee.getCache(cacheName);

Recherchez un cache nommé et créez-le si nécessaire. Le cache généré utilise un ensemble prédéfini de paramètres de configuration adapté à la plupart des situations.

Paramètres :

cacheName : chaîne, nom du cache. (et non le nom de la ressource de cache).

Renvoie :

Objet de cache.

Exemple :

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

(2) getCache

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

Accédez à une ressource de cache personnalisée spécifiée dans un objet de configuration. Pour savoir comment créer une ressource de cache, consultez la section Créer et modifier un cache d'environnement.

Paramètres :

cacheName : chaîne, nom du cache personnalisé. (pas le nom de la ressource de cache)

options : objet de configuration. L'objet peut être vide ou contenir les paramètres facultatifs suivants:

resource: nom d'une "ressource de cache" Apigee dans laquelle les données de cache sont stockées. Les ressources de cache sont utilisées pour affiner l'allocation de mémoire et d'autres paramètres de cache. Si aucune ressource n'est spécifiée, une ressource par défaut est utilisée. Si la ressource de cache n'existe pas, la méthode génère une erreur.
scope: spécifie si les entrées de cache comportent un préfixe pour éviter les conflits. Les valeurs valides sont global, application et exclusive.
- global: toutes les entrées de cache peuvent être vues par toutes les applications Node.js du même "environnement" Apigee.
- application: toutes les entrées de cache peuvent être vues par tous les caches Node.js qui font partie de la même application Apigee Edge.
- exclusive (par défaut) : les entrées de cache ne sont visibles que par les caches Node.js de la même application portant le même nom. Il s'agit de la valeur par défaut.
prefix: si le nom de la clé de cache inclut un préfixe, comme décrit dans les sections Remplir la règle de cache et Utiliser des clés de cache, utilisez ce paramètre pour le spécifier. Edge ajoute automatiquement un suffixe à deux traits de soulignement au nom du préfixe. Par conséquent, si une clé de cache a été créée avec le préfixe "UserToken", le préfixe à spécifier ici est "UserToken__".
defaultTtl: spécifie la valeur TTL par défaut d'une entrée de cache, en secondes. Si cette valeur n'est pas spécifiée, la valeur TTL par défaut de la ressource de cache est utilisée.
timeout: délai d'attente en secondes pour récupérer un résultat à partir du cache distribué. La valeur par défaut est de 30 secondes. Les applications sensibles à la latence peuvent souhaiter réduire ce délai afin d'éviter des temps de réponse lents si l'infrastructure de cache est surchargée.

Renvoie :

Objet de cache personnalisé.

Exemple :

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

Cela fonctionne avec une règle LookupCache configurée comme suit:

<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));

Placer des données dans un cache

Paramètres :

key: (obligatoire) chaîne qui identifie de manière unique l'élément dans le cache. Les clés de cache sont limitées à une taille de 2 Ko.
data: (obligatoire) chaîne, tampon ou objet représentant les données à mettre en cache. Tout autre type de données entraînera une erreur. Pour plus de commodité, les objets seront convertis en chaîne à l'aide de "JSON.stringify".
ttl: (facultatif) Durée maximale de conservation des données dans le cache, en secondes. Si cette valeur n'est pas spécifiée, une valeur TTL par défaut est utilisée.
callback: (facultatif) Si spécifié, fonction appelée une fois que les données sont correctement stockées dans le cache. Elle sera appelée avec un objet Error (erreur) comme premier paramètre en cas d'erreur d'insertion. Sinon, elle sera appelée sans paramètre.

Exemple :

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
});

get

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

Récupérer des données à partir d'un cache

Paramètres :

key (obligatoire): chaîne qui identifie de manière unique l'élément dans le cache.

Pour les entrées de cache placées dans le cache à partir d'une règle Apigee Edge (telle que la règle PopulateCache), vous devez créer la clé de cache en déduisant la manière spécifique dont la règle crée des clés pour les entrées. Pour ce faire, vous devez connaître la configuration de la stratégie. Bien que la section Utiliser des clés de cache explique comment les clés de cache sont créées par des règles, gardez à l'esprit que vous ne devez pas spécifier de valeurs de chaîne liées au champ d'application. Dans les appels de Node.js, le champ d'application fait déjà partie du contexte.
callback (obligatoire): fonction qui est appelée lorsque les données sont disponibles. Si des données sont mises en cache, elles sont renvoyées dans le deuxième paramètre.
- error : objet Error. En cas d'erreur lors de la récupération à partir du cache, un objet Error est défini ici. Sinon, ce paramètre sera défini sur "undefined".
- data : données récupérées, le cas échéant. Il s'agit de l'une des quatre valeurs suivantes:
  - Si une chaîne a été insérée, il s'agira d'une chaîne.
  - Si un tampon a été inséré, ce sera un tampon.
  - Si un objet a été inséré, il s'agit d'une chaîne contenant la version JSON de l'objet telle que produite par "JSON.stringify".
  - Si aucun résultat n'est trouvé, la valeur est "undefined".

Exemple :

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));

Invalider un élément mis en cache Une fois qu'une clé est invalidée, les requêtes get() suivantes renvoient "undefined", sauf si une autre valeur est insérée.

Paramètres :

key (obligatoire): chaîne qui identifie de manière unique l'élément du cache à invalider.

Pour les entrées de cache placées dans le cache à partir d'une règle Apigee Edge (telle que la règle PopulateCache), vous devez créer la clé de cache en déduisant la manière spécifique dont la règle crée des clés pour les entrées. Pour ce faire, vous devez savoir comment la règle est configurée. Bien que Utiliser des clés de cache explique comment les clés de cache sont créées par les règles, gardez à l'esprit que vous ne devez pas spécifier de valeurs de chaîne liées à la portée. Dans les appels à partir de Node.js, la portée fait déjà partie du contexte.
callback (obligatoire): fonction de rappel qui sera appelée avec un objet Error comme premier paramètre en cas d'erreur.

Exemple :

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