Cache une base de données MongoDB avec redis

Ce didacticiel montre comment augmenter les performances d'un service Web Node.js interagissant avec une base de données MongoDB en implémentant une couche de mise en cache Redis. Nous allons construire une application "FastLibrary" pour illustrer le concept.

Avantages clés de la mise en cache redis:

• Améliore considérablement les performances de lecture en stockant les données fréquemment accessibles dans le stockage rapide et en mémoire de Redis.
• réduit la charge sur la base de données MongoDB, empêchant les goulots d'étranglement de performances sous forme d'échelles de données.
• La politique d'expulsion du cache LRU (la moins récemment utilisée) de Redis gère automatiquement l'utilisation de la mémoire.

Comprendre la hiérarchie de mémoire:

La mise en cache aborde le compromis inhérent entre la capacité de stockage et la vitesse. Les disques durs offrent une grande capacité mais un accès lent, tandis que la RAM est plus rapide mais plus petite. Les registres du CPU sont les plus rapides mais ont une capacité minimale. Un cache agit comme un intermédiaire à grande vitesse, stockant les données fréquemment accessibles dans une mémoire plus rapide (comme RAM). Le diagramme ci-dessous illustre ceci:

Construire l'application "FastLibrary":

Nous créerons un service Web simple avec deux points de terminaison:

• POST /book: Crée une nouvelle entrée de livre dans MongoDB.
• GET /book/:title: récupère le contenu d'un livre par titre.

Étape 1: Configuration du projet:

1. Créez un répertoire de projet et initialisez NPM: mkdir fastLibrary && cd fastLibrary && npm init
2. Installez les dépendances: npm install express mongodb redis --save

Étape 2: Interaction de base MongoDB:

Le module access.js gère les opérations de la base de données:

<code class="language-javascript">module.exports.saveBook = (db, title, author, text, callback) => {
    db.collection('text').save({ title, author, text }, callback);
};

module.exports.findBookByTitle = (db, title, callback) => {
    db.collection('text').findOne({ title }, (err, doc) => {
        if (err || !doc) callback(null);
        else callback(doc.text);
    });
};</code>

Le fichier index.js configure le serveur express et se connecte à MongoDB:

<code class="language-javascript">// ... (require statements and MongoDB connection as before) ...

app.post('/book', (req, res) => {
    // ... (save book logic as before) ...
});

app.get('/book/:title', (req, res) => {
    // ... (get book logic, updated later with caching) ...
});

// ... (app.listen as before) ...</code>

Étape 3: Intégration de la mise en cache Redis:

1. Initialisez le client redis dans index.js:

<code class="language-javascript">const redis = require('redis').createClient({ url: 'redis://localhost:6379' });
redis.connect().catch(console.error);</code>

2. Modifier access.js pour ajouter findBookByTitleCached:

<code class="language-javascript">module.exports.findBookByTitleCached = (db, redis, title, callback) => {
    redis.get(title, (err, reply) => {
        if (err) callback(null);
        else if (reply) callback(JSON.parse(reply)); // Cache hit
        else { // Cache miss
            db.collection('text').findOne({ title }, (err, doc) => {
                if (err || !doc) callback(null);
                else {
                    redis.set(title, JSON.stringify(doc)); // Add to cache
                    callback(doc.text);
                }
            });
        }
    });
};</code>

3. Mettez à jour le point de terminaison GET /book/:title dans index.js pour utiliser findBookByTitleCached:

<code class="language-javascript">app.get('/book/:title', (req, res) => {
    access.findBookByTitleCached(db, redis, req.params.title, (book) => {
        if (!book) res.status(404).send('Book not found');
        else res.send(book);
    });
});</code>

Étape 4: Configuration de Redis LRU:

Démarrer Redis avec LRU activé et une limite de mémoire (ajustez au besoin):

<code class="language-bash">redis-server --maxmemory 512mb --maxmemory-policy allkeys-lru</code>

Étape 5: Gestion des mises à jour du cache (put la pointe):

Ajoutez un point de terminaison pour mettre à jour les livres et mettre à jour le cache en conséquence. Cela nécessite d'ajouter une fonction updateBookByTitle à access.js et un point de terminaison PUT /book/:title à index.js. (Détails d'implémentation omis pour la concision, mais similaire à la logique de mise en cache ci-dessus).

Test de performance et conclusion:

Après la mise en œuvre de la mise en cache, comparez les mesures de performance (temps de réponse) avec et sans mise en cache pour observer l'amélioration. N'oubliez pas que l'optimisation prématurée peut être nocive, évaluez soigneusement si la mise en cache est nécessaire et appropriée pour votre application. Considérez des facteurs tels que les ratios de lecture / écriture, la complexité de la requête et les exigences de cohérence des données. Les FAQ fournies offrent des informations supplémentaires sur ces considérations.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!