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

Accéder au cache dans Node.js

<ph type="x-smartling-placeholder"></ph> Vous consultez la documentation Apigee Edge.
Accédez à la page Documentation sur Apigee X. En savoir plus

Avis d'abandon du Private Cloud :

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

Depuis 2013, Apigee prend en charge Utilisation de proxys Node.js dans Apigee Edge à l'aide 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 de Private Cloud de suivre les étapes suivantes:

Migrez des données dans des coffres-forts sécurisés vers Mappages de clés-valeurs chiffrés (KVM) pour accéder aux données sensibles depuis un proxy d'API.
Migrer des proxys d'API basés sur Trireme (Node.js) vers un environnement Node.js natif en dehors d'Apigee.

Consultez également Abandons et suppressions d'Apigee.

Vous pouvez utiliser le module apigee-access pour accéder au cache distribué Edge à partir de dans une application Node.js. Le module inclut des méthodes permettant d'obtenir cache et de putting, get 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, est un cache utilisé le moins récemment et avec une taille maximale. Dans Apigee Edge, le cache est distribué entre tous les nœuds où s'exécute votre application Node.js. Vous pouvez gérer le cache à l'aide d'une l'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: Usage général mise en cache.

Pour 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 obtenu utilise un ensemble prédéfini de paramètres de configuration adaptés à la plupart des situations.

Paramètres :

cacheName : une chaîne. Le nom du cache. (et non le 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édez à une ressource de cache personnalisée spécifiée dans un objet de configuration. Pour savoir comment pour créer une ressource de cache, consultez la section Créer et modifier un environnement cache.

Paramètres :

cacheName : une chaîne. Le nom du un cache personnalisé. (Il ne s'agit pas du nom de la ressource de cache)

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

resource: nom d'une "ressource de cache" Apigee. où sont stockées. Les ressources de cache permettent d'ajuster l'allocation de mémoire et d'autres paramètres. Si aucune valeur n'est spécifiée, une ressource par défaut est utilisée. Si la ressource de cache n'est pas existe, alors la méthode génère une erreur.
scope: indique si les entrées de cache sont précédées du préfixe pour éviter les collisions. 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 le même "environnement" Apigee.
- application: toutes les entrées de cache peuvent être vues par tous les caches Node.js qui sont 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 du une 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, tel que décrits dans la section Renseigner "Règle de cache" et Utiliser des clés de cache, utilisez ce paramètre pour le spécifier. Edge ajoute automatiquement un double trait de soulignement au son nom de préfixe. Ainsi, si une clé de cache a été créée avec le préfixe "UserToken", le préfixe ici, "UserToken__".
defaultTtl: spécifie la valeur TTL par défaut pour un cache. en secondes. Si aucune valeur n'est spécifiée, la valeur TTL par défaut de la ressource de cache sera utilisé.
timeout: délai d'attente avant la récupération d'un résultat à partir du distribué, en quelques secondes. La valeur par défaut est de 30 secondes. Les applications sensibles à la latence peuvent réduire ce nombre afin d'éviter des temps de réponse lents si l'infrastructure de cache surchargés.

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

Mettre des données dans un cache

Paramètres :

key: (obligatoire) chaîne qui identifie de manière unique l'élément en cache. Les clés de cache sont limitées à une taille de 2 Ko.
data: (obligatoire) chaîne, tampon ou objet qui qui représente les données à mettre en cache. Tout autre type de données entraînera une erreur. Pour plus de commodité, seront convertis en chaîne à l'aide de "JSON.stringify".
ttl: (facultatif) durée maximale de persistance du les données en cache, en quelques secondes. Si aucune valeur n'est spécifiée, une valeur TTL par défaut est utilisée.
callback: (facultatif) fonction qui est appelé une fois que les données sont dans le cache. Il sera appelé avec un objet Error (Error) en tant que premier paramètre en cas d'erreur d'insertion, sinon il est appelé avec aucun 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 qui identifie de manière unique l'élément en cache.

Pour les entrées de cache placées dans le cache à partir d'une stratégie Apigee Edge (telle que Remplir la règle de cache), vous devra construire la clé de cache en déduisant de la façon spécifique dont la stratégie crée clés pour les entrées. Pour ce faire, vous devez savoir comment la règle est configurée. Alors que Utiliser des clés de cache décrit comment les clés de cache sont créées par des stratégies, gardez à l'esprit que vous ne devez pas spécifier Valeurs de chaîne liées au champ d'application dans les appels de Node.js, le champ d'application fait déjà partie le contexte.
callback (obligatoire): fonction qui sera appelée lorsque les données sont disponibles. Si des données sont mises en cache, elles sont renvoyées dans la seconde .
- error : objet "Error". En cas d'erreur lors de l'extraction depuis le cache, un objet Error est défini ici. Dans le cas contraire, sera défini sur "undefined".
- data : données récupérées, le cas échéant. Ce sera 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'agira d'une chaîne contenant la version JSON de comme produit par "JSON.stringify".
  - Si rien n'a été trouvé, la valeur sera "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

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 en cache pour l'invalider.

Pour les entrées de cache placées dans le cache à partir d'une stratégie Apigee Edge (telle que Remplir la règle de cache), vous devra construire la clé de cache en déduisant de la façon spécifique dont la stratégie crée clés pour les entrées. Pour ce faire, vous devez savoir comment la règle est configurée. Alors que Utiliser des clés de cache décrit comment les clés de cache sont créées par des stratégies, gardez à l'esprit que vous ne devez pas spécifier Valeurs de chaîne liées au champ d'application dans les appels de Node.js, le champ d'application fait déjà partie le contexte.
callback (obligatoire): fonction de rappel qui être appelé avec un objet Error (erreur) comme premier paramètre en cas d'erreur.

Exemple :

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