La mise en cache est une stratégie qui peut vous aider à conserver les ressources et à améliorer les performances. Lorsque vous avez une requête coûteuse souvent exécutée avec un résultat qui change rarement, la mise en cache est une solution idéale. En mettant en cache le résultat de cette requête, vous pouvez renvoyer le résultat mis en cache si nécessaire. Le résultat est le même, mais vous évitez d’avoir à exécuter la requête coûteuse. Tout le monde y gagne.
Dans cet article, nous allons parcourir l’utilisation des fonctions Salesforce pour mettre en cache les requêtes coûteuses. Par exemple, nous souhaitons interroger une valeur sur un grand nombre d’enregistrements, et la page nécessitant cette requête est souvent chargée. Cependant, le résultat ne changera pas d’une exécution de requête à l’autre.
Présentation du problème
Dans notre démo, l’exemple de requête sera « le nombre d’entreprises de plus de 10 000 salariés.” Nous imaginons un cas d’utilisation dans lequel il y a une page que notre équipe commerciale charge souvent, et une partie de la page affiche le nombre total d’entreprises de notre organisation Salesforce qui correspondent à cette condition. Idéalement, la requête coûteuse n’est pas exécutée à chaque chargement de la page, mais à la place, nous implémenterions un mécanisme de mise en cache.
Pour résoudre cela, nous allons :
- Utilisez Heroku Connect pour synchroniser notre liste d’entreprises de Salesforce à Heroku Postgres (ou utilisez une table déjà dans Postgres).
- Créez une fonction Salesforce pour interroger Postgres et renvoyer ce nombre.
- Stockez la valeur résultante dans Heroku Redis pendant une durée spécifiée.
- Utilisez une fonction Salesforce pour vérifier la valeur dans Redis. Si la valeur existe dans Redis, renvoyez-la. Si ce n’est pas le cas, exécutez la requête et stockez le résultat dans Redis.
Le flux de données ressemble à ceci :
Bien sûr, Apex dispose d’une API Platform Cache pour faciliter la mise en cache pour certains cas d’utilisation. Pour notre cas d’utilisation et à des fins de démonstration, nous allons explorer cette solution de mise en cache qui utilise Salesforce Functions.
Avant de continuer, présentons brièvement chacune des pièces de notre système.
- Fonction Salesforce : fonctionnalité de Salesforce qui vous permet d’exécuter du code (JavaScript ou Java sont actuellement les langages pris en charge) qui se trouve toujours dans la zone sécurisée de votre organisation Salesforce, mais ne s’exécute pas sur votre organisation. Cela vous permet de décharger les charges de travail lourdes ou susceptibles de vous faire dépasser les limites.
- Heroku Connect : un outil de la famille Salesforce pour la synchronisation bidirectionnelle des données entre votre organisation Salesforce et Heroku Postgres. Semblable aux fonctions Salesforce, vous pouvez tirer parti de cet outil sans affecter vos limites Salesforce.
- Heroku Postgres : une instance entièrement gérée de PostgreSQL (une base de données relationnelle) sur Heroku.
- Heroku Redis : une instance entièrement gérée de Redis (un magasin clé-valeur en mémoire) sur Heroku.
Conditions préalables
Pour utiliser tous les composants ci-dessus, vous devez disposer des éléments suivants :
Avec les conditions préalables en place, nous pouvons commencer à les connecter. Tout d’abord, nous allons parcourir la connexion des environnements. Ensuite, nous examinerons le code nécessaire pour que la magie opère.
Accès aux services de données Heroku à partir d’une fonction Salesforce
Avec vos comptes et accès en place, nous pouvons aller de l’avant avec la fonction elle-même. Supposons que vous démarrez un nouveau projet et que vous avez une base de données Postgres vide.
Si vous êtes nouveau dans les fonctions, nous vous recommandons de suivre ce processus de base pour avoir une idée des choses avant d’impliquer des pièces supplémentaires. Si vous avez déjà un projet Salesforce ou si vous synchronisez les données via Heroku Connect, vous pouvez modifier les commandes suivantes en fonction de vos besoins.
Tout d’abord, créez un projet Salesforce DX pour héberger votre fonction.
sfdx force:project:create -n MyDataProjEnsuite, accédez au répertoire du projet et exécutez la commande suivante pour créer une nouvelle fonction JavaScript.
sf generate function -n yourfunction -l javascript
Cela va créer un /functions dossier avec un modèle d’application Node.js.
Ensuite, associez votre fonction Salesforce et vos environnements Heroku en ajoutant votre utilisateur Heroku en tant que collaborateur à l’environnement de calcul de votre fonction :
sf env compute collaborator add --heroku-user <yourherokuaccount@email.com>
Les environnements peuvent désormais partager les services de données Heroku.
Ensuite, vous devrez obtenir le nom de l’environnement informatique afin de pouvoir y attacher les magasins de données.
Pour attacher les banques de données Heroku, vous avez également besoin des noms des add-ons. Vous pouvez obtenir le nom des modules complémentaires avec la commande suivante :
heroku addons -a <yourherokuapp>
La sortie ressemblera à ce qui suit. Le « nom » de chaque module complémentaire est affiché en violet (par exemple, postgresql-closed-46065).
Avec les noms de l’environnement informatique et de vos modules complémentaires, exécutez les commandes suivantes pour attacher Postgres et Redis à votre environnement informatique :
heroku addons:attach <your-heroku-postgres-name> --app <your-compute-environment-name>
heroku addons:attach <your-heroku-redis-name> --app <your-compute-environment-name>Maintenant que nous avons connecté notre environnement Salesforce Function à nos magasins de données Heroku, nous pouvons écrire notre code Salesforce Function.
Implémentation de la fonction Salesforce
Avant de commencer à écrire le JavaScript pour cette fonction Salesforce, configurons notre environnement de développement local avec les bibliothèques nécessaires. Dans l’environnement déployé, notre fonction obtiendra les informations de connexion de données à partir des variables d’environnement. Pour notre environnement local, nous utiliserons le package de nœud dotenv pour lire un fichier nommé .env avec ces informations. Nous pouvons créer ce fichier avec la commande suivante :
heroku config -a <yourherokuapp> --shell > .env
Ensuite, installons les packages dont nous avons besoin pour interagir avec Postgres et Redis, ainsi que dotenv :
npm install dotenv pg redis
La configuration de notre projet est terminée. Écrivons notre code de fonction.
Connectez-vous à Heroku Postgres et Redis
Commençons par ajouter le code qui nous permet de lire et de stocker des données dans Heroku Postgres et Heroku Redis. (Remarque : Heroku Devcenter contient une documentation utile sur la connexion à Postgres et Redis à partir de Node.js.)
Notre code de fonction vivra dans le index.js dossier de la functions dossier dans notre projet (par exemple, MyDataProj/functions/index.js). Nous ouvrons ce fichier et ajoutons les lignes suivantes en haut. Ces lignes importeront les modules que nous venons d’installer.
import "dotenv/config";
import pg from "pg";
const { Client } = pg;
import { createClient } from 'redis';La partie principale de la fonction est la section qui est exportée. La valeur renvoyée par ce bloc sera renvoyée à l’appelant de la fonction.
export default async function (event, context, logger) {
}Pour garder notre code propre et modulaire, écrivons d’abord plusieurs fonctions d’assistance au bas du fichier. Nous avons besoin de fonctions que nous pouvons appeler pour gérer notre connexion à Postgres et Redis. Sous (et en dehors de) la fonction exportée, nous ajoutons les deux fonctions d’assistance suivantes :
/* Helper functions */
// Connect to PostgreSQL
async function pgConnect() {
const DATABASE_URL = process.env.DATABASE_URL;
if (!DATABASE_URL) {
throw new Error("DATABASE_URL is not set");
}
const client = new Client({
connectionString: DATABASE_URL,
ssl: {
rejectUnauthorized: false
}
});
await client.connect();
return client;
}
// Connect to Redis
async function redisConnect() {
const REDIS_URL = process.env.REDIS_URL;
if (!REDIS_URL) {
throw new Error("REDIS_URL is not set");
}
const redis = createClient({
url: process.env.REDIS_URL,
socket: {
tls: true,
rejectUnauthorized: false
}
});
await redis.connect();
redis.on('error', err => {
console.log('Error ' + err);
});
return redis;
}Pour garder notre exemple simple, chargeons un petit jeu de données dans Postgres. Nous pouvons créer une table appelée « société » en exécutant les commandes de base de données trouvées dans l’essentiel suivant. Téléchargez le contenu de cet essentiel dans un fichier appelé company.sql. Pour exécuter les commandes de base de données à partir de la CLI Heroku, procédez comme suit :
heroku pg:psql -a <yourherokuapp>
DATABASE=> \i /path/to/company.sqlVous pouvez vérifier que votre exemple d’ensemble de données a été chargé en exécutant la requête suivante :
DATABASE=> select * from company;
Écrire la fonction principale
Nous sommes tous installés ! Maintenant, nous avons un peu de code à écrire pour notre fonction actuelle. Le code de notre fonction est disponible sous forme d’essentiel et ressemble à ceci. Vous pouvez le copier dans votre index.js dossier. Nous allons parcourir et expliquer chaque section du code.
export default async function (event, context, logger) {
logger.info(`Invoking Datafunction with payload ${JSON.stringify(event.data || {})}`);
const redis = await redisConnect();
let cached = {};
// Check Redis for cached entry first
let big_biz_count = await redis.get(`big_biz`);
if (big_biz_count) {
// If cached entry found, return it and be done.
logger.info(`Found cache entry = ${big_biz_count}`);
cached = "true"
redis.quit();
return { big_biz_count, cached }
} else {
// If cached entry not found, then:
// 1. Run the Postgres query
// 2. Store the result in Redis
// 3. Return the result and be done
logger.info(`did not find in cache, returned ${big_biz_count}`);
cached = "false"
const pg = await pgConnect();
const { rows } = await pg.query('SELECT COUNT(*) FROM company WHERE employees>10000;');
big_biz_count = rows[0].count.toString();
redis.set(`big_biz`, big_biz_count, {
EX: 30, // seconds to keep before expiring
NX: true
});
// Close the connections
redis.quit();
pg.end();
// Return the value from Postgres, now stored in Redis
return { big_biz_count, cached }
}
}