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

Accéder au cache dans Node.js

Vous consultez la documentation d'Apigee Edge.
Consultez la documentation Apigee X. en savoir plus

Avis d'abandon de Private Cloud:

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

Depuis 2013, Apigee prend en charge l'utilisation de proxys Node.js dans Apigee Edge par le biais de Trireme, qui vous permet d'exécuter votre code Node.js dans Apigee Edge pour le cloud privé et de l'exposer en tant qu'API.

Apigee recommande aux clients Private Cloud de procéder comme suit:

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

Consultez également Abandons et retraits 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, ainsi que d'insérer, d'obtenir et de 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 le moins récemment utilisé et d'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 une introduction à 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 obtenir 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

var
  cache = apigee.getCache(cacheName);

Recherchez un cache nommé et créez-le si nécessaire. Le cache obtenu utilise un ensemble prédéfini de paramètres de configuration adapté à 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

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

Accéder à une ressource de cache personnalisée spécifiée dans un objet de configuration Pour plus d'informations sur la création d'une ressource de cache, consultez la section Créer et modifier un cache d'environnement.

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 où 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 sera 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 sont visibles par tous les caches Node.js faisant 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 et 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 de double trait de soulignement au nom de préfixe. Ainsi, 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 vous n'indiquez aucune valeur, la valeur TTL par défaut de la ressource de cache sera utilisée.
timeout: délai d'attente en secondes avant la récupération d'un résultat à partir du cache distribué. La valeur par défaut est de 30 secondes. Il est recommandé aux applications sensibles à la latence de la réduire afin d'éviter les temps de réponse lents si l'infrastructure du 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>

indiquer

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

Mettre les données en cache

Paramètres :

key: (obligatoire) chaîne identifiant 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 qui représente 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 aucune valeur n'est spécifiée, une valeur TTL par défaut sera utilisée.
callback: (facultatif) si spécifié, une fonction qui sera appelée une fois que les données seront en cache de manière sécurisée. Elle est appelée avec un objet Error comme premier paramètre en cas d'erreur d'insertion. Sinon, elle est 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
});

obtenir

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

Récupérer les données d'un cache

Paramètres :

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

Pour les entrées de cache placées dans le cache à partir d'une stratégie Apigee Edge (telle que règle Remplir le cache), vous devez construire la clé de cache en déduisant de la manière dont la stratégie crée les clés pour les entrées. Pour ce faire, vous devez connaître la configuration de la règle. Bien que la section Utiliser des clés de cache explique comment les clés de cache sont créées par des règles, n'oubliez pas 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 "Erreur". Si une erreur se produit 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é, il s'agit d'un tampon.
  - Si un objet a été inséré, il s'agit d'une chaîne contenant la version JSON de l'objet produite par "JSON.stringify".
  - Si rien n'a été trouvé, il sera "indéfini".

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

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

Invalider un élément mis en cache. Lorsqu'une clé n'est plus valide, les requêtes get() ultérieures renvoient "undefined", sauf si une autre valeur est insérée.

Paramètres :

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

Pour les entrées de cache placées dans le cache à partir d'une stratégie Apigee Edge (telle que règle Remplir le cache), vous devez construire la clé de cache en déduisant de la manière dont la stratégie crée les clés pour les entrées. Pour ce faire, vous devez connaître la configuration de la règle. Bien que la section Utiliser des clés de cache explique comment les clés de cache sont créées par des règles, n'oubliez pas 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 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) {
});