Accéder au cache dans Node.js

Vous consultez la documentation Apigee Edge.
Accédez à la documentation**Apigee X**. info

Vous pouvez utiliser le apigee-access module 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 d'y placer, de les récupérer et de les 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 LRU (Least Recently Used) avec une taille maximale. Dans Apigee Edge, le cache est distribué 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 une présentation de la mise en cache sur Apigee Edge, consultez la section Outils de persistance dans Edge. Pour en savoir plus sur le cache distribué, consultez la section Exemple : Mise en cache à usage général.

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

Méthodes

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

(1) getCache

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

Paramètres :

cacheName : chaîne, nom du cache. (Il ne s'agit pas du nom de la ressource de cache.)

Renvoie :

Un objet de cache.

Exemple :

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

(2) getCache

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 cache.

Paramètres :

cacheName : chaîne, nom du cache personnalisé. (Il ne s'agit pas du 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 permettent d'ajuster l'allocation de mémoire et d'autres paramètres de cache. Si aucune valeur 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 sont préfixées 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 dans le 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 vues 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 la section Règle de remplissage de cache et Utiliser des clés de cache, utilisez ce paramètre pour le spécifier. Edge ajoute automatiquement un suffixe de double trait 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 (Time To Live) par défaut d'une entrée de cache en secondes. Si aucune valeur n'est spécifiée, la valeur TTL par défaut de la ressource de cache est utilisée.

• timeout : délai d'attente pour récupérer un résultat du cache distribué, en secondes. La valeur par défaut est de 30 secondes. Les applications sensibles à la latence peuvent souhaiter réduire cette valeur afin d'éviter les temps de réponse lents si l'infrastructure de cache est surchargée.

Renvoie :

Un 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

Placez 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, mémoire 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 persistance des données dans le cache, en secondes. Si aucune valeur n'est spécifiée, une valeur TTL par défaut est utilisée.

• callback: (facultatif) si spécifié, fonction qui sera appelée une fois que les données seront sécurisées dans le cache. Elle sera appelée avec un objet Error comme premier paramètre en cas d'erreur d'insertion, et sans paramètre dans le cas contraire.

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

Récupérez les données 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 règle de remplissage de cache), vous devez construire 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 la section Utiliser des clés de cache décrive comment les clés de cache sont créées par les règles, n'oubliez pas que vous ne devez pas spécifier de valeurs de chaîne liées à la portée. Dans les appels depuis Node.js, la portée fait déjà partie du contexte.

• callback (obligatoire) : fonction qui sera appelée lorsque les données seront disponibles. Si des données mises en cache sont disponibles, 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. Dans le cas contraire, ce paramètre est 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'agit d'une chaîne.
    • Si une mémoire tampon a été insérée, il s'agit d'une mémoire tampon.
    • Si un objet a été inséré, il s'agit d'une chaîne contenant la version JSON de l' objet telle qu'elle est produite par "JSON.stringify".
    • Si rien n'a été 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
});

supprimer

Invalidez 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 à invalider dans le cache.

  Pour les entrées de cache placées dans le cache à partir d'une règle Apigee Edge (telle que règle de remplissage de cache), vous devez construire 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 la section Utiliser des clés de cache décrive comment les clés de cache sont créées par les règles, n'oubliez pas que vous ne devez pas spécifier de valeurs de chaîne liées à la portée. Dans les appels depuis 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) {
});