Gérer les erreurs de MongoDB

Introduction

Dans ce laboratoire, vous allez apprendre à gérer diverses erreurs de MongoDB, y compris les erreurs de connexion, les erreurs d'écriture, les erreurs de requête et les problèmes de clé en double. Vous allez explorer différents types d'erreurs de connexion, telles que des chaînes de connexion incorrectes et des problèmes d'authentification, et apprendre à les diagnostiquer et à les résoudre. De plus, vous découvrirez des techniques pour gérer les erreurs d'écriture, traiter les erreurs de requête et réessayer les opérations ayant échoué pour garantir la fiabilité et la robustesse de vos applications MongoDB.

Skills Graph

Gérer les erreurs de connexion

Dans cette étape, vous allez apprendre à gérer les erreurs de connexion dans MongoDB, qui sont des défis courants lorsqu'on travaille avec des bases de données. Les erreurs de connexion peuvent survenir pour diverses raisons, telles que des chaînes de connexion incorrectes, des problèmes réseau ou des problèmes d'authentification.

Comprendre les erreurs de connexion de MongoDB

Commençons par explorer différents types d'erreurs de connexion et la manière de les diagnostiquer et de les résoudre. Nous utiliserons le shell MongoDB (mongosh) pour démontrer ces scénarios.

Tout d'abord, ouvrez un terminal et lancez le shell MongoDB :

mongosh

Simulation d'erreurs de connexion

1. Chaîne de connexion incorrecte

Essayez de vous connecter à une instance MongoDB inexistante :

mongosh "mongodb://localhost:27018/testdb"

Sortie exemple :

MongoNetworkError: impossible de se connecter au serveur [localhost:27018] lors de la première tentative de connexion

Cette erreur se produit lorsque la chaîne de connexion pointe vers un port ou un hôte sur lequel aucun serveur MongoDB n'est en cours d'exécution.

2. Erreurs d'authentification

Simulons une erreur d'authentification en utilisant un nom d'utilisateur ou un mot de passe incorrect :

mongosh "mongodb://wronguser:wrongpassword@localhost:27017/testdb"

Sortie exemple :

MongoAuthenticationError: Échec de l'authentification

Gérer les erreurs de connexion en pratique

Pour gérer efficacement les erreurs de connexion, vous devriez :

1. Vérifier les détails de la connexion
2. Vérifier la connectivité réseau
3. Vérifier que le service MongoDB est en cours d'exécution
4. Vérifier les informations d'identification d'authentification

Exemple de gestion d'erreurs de connexion

Créez un script simple de gestion d'erreurs en Node.js pour démontrer une gestion de connexion robuste :

const { MongoClient } = require("mongodb");

const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, {
  serverSelectionTimeoutMS: 5000,
  connectTimeoutMS: 5000
});

async function connectToMongoDB() {
  try {
    await client.connect();
    console.log("Connecté avec succès à MongoDB");
  } catch (error) {
    console.error("Erreur de connexion :", error.message);
    // Implémentez une logique de reconnexion ou un mécanisme de repli
  } finally {
    await client.close();
  }
}

connectToMongoDB();

Ce script montre :

• La définition de délais d'attente de connexion
• La capture d'erreurs de connexion
• La journalisation des détails de l'erreur
• La fermeture correcte de la connexion

Meilleures pratiques pour la gestion d'erreurs de connexion

1. Toujours utiliser des délais d'attente de connexion
2. Implémenter des mécanismes de reconnexion
3. Journaliser des informations d'erreur détaillées
4. Vérifier les chaînes de connexion avant de vous connecter
5. Utiliser des variables d'environnement pour les détails de la connexion

Gérer les erreurs d'écriture

Dans cette étape, vous allez apprendre à gérer les erreurs d'écriture dans MongoDB, qui peuvent survenir lors d'opérations d'insertion, de mise à jour ou de suppression de documents. Comprendre et gérer ces erreurs est crucial pour maintenir l'intégrité des données et prévenir des problèmes inattendus dans votre base de données.

Comprendre les erreurs d'écriture de MongoDB

Explorons différents types d'erreurs d'écriture et la manière de les gérer efficacement en utilisant le shell MongoDB (mongosh).

Tout d'abord, assurez-vous d'être connecté au shell MongoDB :

mongosh

Types d'erreurs d'écriture

1. Erreur de clé en double

Créez une collection avec un index unique pour démontrer les erreurs de clé en double :

use errorlab
db.users.createIndex({ email: 1 }, { unique: true })
db.users.insertMany([
  { name: "John Doe", email: "[email protected]" },
  { name: "Jane Doe", email: "[email protected]" }
])

Sortie exemple :

MongoError: E11000 erreur de clé en double collection: errorlab.users index: email_1 dup key: { email: "[email protected]" }

2. Erreur de validation

Créez une validation de schéma pour empêcher l'insertion de données invalides :

db.createCollection("products", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: ["name", "price"],
         properties: {
            name: {
               bsonType: "string",
               description: "doit être une chaîne et est obligatoire"
            },
            price: {
               bsonType: "number",
               minimum: 0,
               description: "doit être un nombre positif et est obligatoire"
            }
         }
      }
   }
})

// Essayez d'insérer un document invalide
db.products.insertOne({ name: 123, price: -10 })

Sortie exemple :

MongoError: Le document a échoué la validation

Gérer les erreurs d'écriture en pratique

Gestion d'erreurs avec Node.js

Créez un script robuste de gestion d'erreurs d'écriture :

const { MongoClient } = require("mongodb");

async function handleWriteErrors() {
  const uri = "mongodb://localhost:27017";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("errorlab");
    const users = database.collection("users");

    try {
      await users.insertOne({
        name: "Alice",
        email: "[email protected]"
      });
      console.log("Document inséré avec succès");
    } catch (writeError) {
      if (writeError.code === 11000) {
        console.error("Erreur de clé en double :", writeError.message);
        // Implémentez une gestion personnalisée pour les clés en double
      } else {
        console.error("Erreur d'écriture :", writeError);
      }
    }
  } catch (connectionError) {
    console.error("Erreur de connexion :", connectionError);
  } finally {
    await client.close();
  }
}

handleWriteErrors();

Meilleures pratiques pour la gestion des erreurs d'écriture

1. Utilisez des index uniques pour empêcher les entrées en double
2. Implémentez une validation de schéma
3. Utilisez des blocs try-catch pour la gestion d'erreurs
4. Journalisez des informations d'erreur détaillées
5. Implémentez des mécanismes de reconnexion ou de repli

Gérer les erreurs de requête

Dans cette étape, vous allez apprendre à gérer diverses erreurs de requête dans MongoDB, à comprendre les pièges courants et à mettre en œuvre des stratégies robustes de gestion d'erreurs pour les requêtes de base de données.

Comprendre les erreurs de requête de MongoDB

Explorons différents types d'erreurs de requête et la manière de les gérer efficacement en utilisant le shell MongoDB (mongosh).

Tout d'abord, assurez-vous d'être connecté au shell MongoDB :

mongosh

Préparer des données d'exemple

Créez une collection d'exemple pour nos démonstrations d'erreurs de requête :

use querylab
db.products.insertMany([
  { name: "Ordinateur portable", price: 1000, category: "Électronique" },
  { name: "Téléphone intelligent", price: 500, category: "Électronique" },
  { name: "Casques", price: 200, category: "Accessoires" }
])

Types d'erreurs de requête

1. Syntaxe de requête invalide

Démontrons une erreur de syntaxe de requête courante :

// Opérateur de comparaison incorrect
db.products.find({ price: { $invalidOperator: 500 } })

Sortie exemple :

MongoError: opérateur de niveau supérieur inconnu : $invalidOperator

2. Requête sur un champ inexistant

Essayez de faire une requête sur un champ qui n'existe pas :

// Requête sur un champ qui n'existe pas
db.products.find({ nonexistentField: "valeur" })

Cela ne générera pas d'erreur mais renverra un ensemble de résultats vide.

3. Incongruence de type dans les requêtes

Démontrons les défis liés aux requêtes de type :

// Requête avec incongruence de type
db.products.find({ price: "500" })  // Chaîne au lieu de nombre

Gestion avancée des erreurs de requête

Créez un script Node.js pour démontrer une gestion robuste des erreurs de requête :

const { MongoClient } = require("mongodb");

async function handleQueryErrors() {
  const uri = "mongodb://localhost:27017";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("querylab");
    const products = database.collection("products");

    try {
      // Requête sécurisée avec gestion d'erreurs
      const query = { price: { $gt: 0 } };
      const options = {
        projection: { _id: 0, name: 1, price: 1 },
        limit: 10
      };

      const cursor = products.find(query, options);
      const results = await cursor.toArray();

      if (results.length === 0) {
        console.log("Aucun document correspondant trouvé");
      } else {
        console.log("Résultats de la requête :", results);
      }
    } catch (queryError) {
      // Gestion d'erreur spécifique
      if (queryError.name === "MongoError") {
        console.error("Erreur de requête MongoDB :", queryError.message);
      } else {
        console.error("Erreur inattendue :", queryError);
      }
    }
  } catch (connectionError) {
    console.error("Erreur de connexion :", connectionError);
  } finally {
    await client.close();
  }
}

handleQueryErrors();

Meilleures pratiques pour la gestion des erreurs de requête

1. Toujours valider les entrées avant de faire une requête
2. Utiliser des blocs try-catch pour la gestion d'erreurs
3. Mettre en œuvre une vérification de type
4. Utiliser une projection pour contrôler les champs renvoyés
5. Ajouter une journalisation d'erreurs appropriée
6. Gérer les ensembles de résultats vides de manière gracieuse

Résoudre les clés en double

Dans cette étape, vous allez apprendre à identifier, prévenir et résoudre les erreurs de clé en double dans MongoDB, un défi courant lors du maintien de l'intégrité des données.

Comprendre les défis liés aux clés en double

Explorons les stratégies pour gérer les clés en double en utilisant le shell MongoDB (mongosh).

Tout d'abord, assurez-vous d'être connecté au shell MongoDB :

mongosh

Création d'un index unique

Commencez par créer une collection avec une contrainte unique :

use duplicatelab
db.users.createIndex({ email: 1 }, { unique: true })

Gérer les scénarios de clé en double

1. Empêcher les insertions en double

Essayez d'insérer des documents en double :

db.users.insertMany([
  { name: "John Doe", email: "[email protected]" },
  { name: "Jane Doe", email: "[email protected]" }
])

Sortie exemple :

MongoError: E11000 erreur de clé en double collection: duplicatelab.users index: email_1 dup key: { email: "[email protected]" }

2. Gérer les doublons avec upsert

Utilisez la méthode updateOne avec upsert pour gérer les doublons :

db.users.updateOne(
  { email: "[email protected]" },
  { $set: {
    name: "John Doe Mis à jour",
    lastUpdated: new Date()
  }},
  { upsert: true }
)

Gestion avancée des clés en double

Créez un script Node.js pour démontrer une gestion robuste des clés en double :

const { MongoClient } = require("mongodb");

async function handleDuplicateKeys() {
  const uri = "mongodb://localhost:27017";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("duplicatelab");
    const users = database.collection("users");

    // Vérifiez l'index unique
    await users.createIndex({ email: 1 }, { unique: true });

    const documentsUtilisateur = [
      { name: "Alice", email: "[email protected]" },
      { name: "Bob", email: "[email protected]" }
    ];

    try {
      // Écriture en bloc avec gestion des doublons
      const opérationsDeBulk = documentsUtilisateur.map((utilisateur) => ({
        updateOne: {
          filtre: { email: utilisateur.email },
          mise à jour: { $set: utilisateur },
          upsert: true
        }
      }));

      const résultat = await users.bulkWrite(opérationsDeBulk);
      console.log("Résultat de l'écriture en bloc :", résultat);
    } catch (erreurDécriture) {
      if (erreurDécriture.code === 11000) {
        console.error("Erreur de clé en double :", erreurDécriture.message);
        // Implémentez une logique de gestion personnalisée des doublons
      } else {
        console.error("Erreur d'écriture inattendue :", erreurDécriture);
      }
    }
  } catch (erreurConnexion) {
    console.error("Erreur de connexion :", erreurConnexion);
  } finally {
    await client.close();
  }
}

handleDuplicateKeys();

Meilleures pratiques pour la gestion des clés en double

1. Utilisez des index uniques pour empêcher les doublons
2. Implémentez des stratégies d'upsert
3. Utilisez des opérations d'écriture en bloc avec une gestion soigneuse
4. Journalisez et suivez les entrées en double
5. Considérez des identifiants uniques alternatifs
6. Implémentez une logique de dédoublonnage au niveau de l'application

Retenter les opérations ayant échoué

Dans cette étape, vous allez apprendre à mettre en œuvre des mécanismes de reconnexion robustes pour les opérations MongoDB ayant échoué, afin de vous assurer que votre application peut gérer les erreurs transitoires et les problèmes réseau.

Comprendre les stratégies de reconnexion d'opération

Explorons différentes approches pour retenir les opérations de base de données ayant échoué en utilisant le shell MongoDB (mongosh) et Node.js.

Tout d'abord, assurez-vous d'être connecté au shell MongoDB :

mongosh

Préparer l'environnement de test

Créez une collection d'exemple pour démontrer les mécanismes de reconnexion :

use retrylab
db.transactions.insertMany([
  { id: 1, montant: 100, statut: "en attente" },
  { id: 2, montant: 200, statut: "en attente" }
])

Stratégies de reconnexion

1. Mécanisme de reconnexion de base

Créez un script Node.js avec une logique de reconnexion simple :

const { MongoClient } = require("mongodb");

async function retryOperation(operation, maxRetries = 3) {
  let retries = 0;

  while (retries < maxRetries) {
    try {
      return await operation();
    } catch (error) {
      retries++;
      console.log(`Tentative ${retries} échouée :`, error.message);

      // Retard exponentiel
      const delay = Math.pow(2, retries) * 1000;
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }

  throw new Error("Nombre maximal de reconnexions dépassé");
}

async function performMongoOperation() {
  const uri = "mongodb://localhost:27017";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("retrylab");
    const transactions = database.collection("transactions");

    // Simulez une opération qui pourrait échouer
    await retryOperation(async () => {
      const result = await transactions.updateOne(
        { id: 1 },
        { $set: { statut: "terminé" } }
      );

      if (result.modifiedCount === 0) {
        throw new Error("Mise à jour échouée");
      }

      console.log("Transaction mise à jour avec succès");
    });
  } catch (error) {
    console.error("Opération finale échouée :", error.message);
  } finally {
    await client.close();
  }
}

performMongoOperation();

2. Reconnexion avancée avec une gestion d'erreur spécifique

Améliorez le mécanisme de reconnexion pour gérer les types d'erreurs spécifiques :

async function advancedRetryOperation(operation, maxRetries = 3) {
  const retryableErrors = [
    "MongoNetworkError",
    "MongoTimeoutError",
    "MongoServerSelectionError"
  ];

  let retries = 0;

  while (retries < maxRetries) {
    try {
      return await operation();
    } catch (error) {
      // Vérifiez si l'erreur est réintégrable
      if (!retryableErrors.includes(error.name)) {
        throw error;
      }

      retries++;
      console.log(`Erreur réintégrable (${error.name}). Tentative ${retries}`);

      // Implémentez un retard exponentiel avec bruit
      const delay = Math.min(
        30000,
        Math.pow(2, retries) * 1000 * (1 + Math.random())
      );

      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }

  throw new Error(
    "Nombre maximal de reconnexions dépassé pour les erreurs réintégrables"
  );
}

Meilleures pratiques pour les reconnexions d'opération

1. Implémentez un retard exponentiel
2. Utilisez des retards avec bruit pour éviter le problème du troupeau tonitruant
3. Limitez le nombre maximal de reconnexions
4. Gérez seulement les erreurs spécifiques et réintégrables
5. Journalisez les tentatives de reconnexion et les résultats finaux
6. Considérez la cohérence transactionnelle

Sommaire

Dans ce laboratoire, vous avez appris à gérer différents types d'erreurs de connexion à MongoDB, y compris des chaînes de connexion incorrectes, des problèmes d'authentification et des problèmes réseau. Vous avez exploré différents scénarios d'erreur en utilisant le shell MongoDB et appris les meilleures pratiques pour diagnostiquer et résoudre les erreurs de connexion, telles que la vérification des détails de connexion, la vérification de la connectivité réseau, l'assurance que le service MongoDB est en cours d'exécution et la validation des informations d'identification d'authentification. Vous avez également mis en œuvre un script simple de gestion d'erreurs en Node.js pour démontrer une gestion robuste de la connexion, qui inclut la définition de délais d'attente appropriés et la gestion gracieuse des erreurs.