Création d'un système de réservation de créneaux évolutif avec des verrous distribués Redis

Dans le monde numérique en évolution rapide d'aujourd'hui, des systèmes de réservation transparents et évolutifs sont essentiels, en particulier lorsque plusieurs utilisateurs tentent de réserver simultanément le même créneau horaire. Ce blog présente une conception de bas niveau d'un Système de réservation de créneaux utilisant Redis pour le verrouillage distribué, qui garantit que les utilisateurs peuvent réserver des créneaux sans rencontrer de conditions de concurrence. En tirant parti de Redis, nous pouvons gérer la simultanéité et l'évolutivité, garantissant ainsi que notre système de réservation fonctionne efficacement en cas de forte demande.

Composants clés du système

Avant de plonger dans les aspects techniques, décomposons les composants principaux :

1. Utilisateur : Représente les individus utilisant le système pour réserver des créneaux horaires.
2. Slot : représente les unités limitées dans le temps (par exemple, salles de réunion, événements) que les utilisateurs peuvent réserver.
3. Redis Distributed Lock : la fonctionnalité clé qui garantit que deux utilisateurs ne peuvent pas réserver le même créneau en même temps.
4. MongoDB : stocke les informations sur l'utilisateur et l'emplacement.
5. Redis : agit en tant que gestionnaire de verrouillage pour gérer les conditions de course.

Les défis des systèmes de réservation

Les systèmes de réservation peuvent facilement devenir la proie de problèmes tels que les doubles réservations ou les conditions de concurrence lorsque plusieurs utilisateurs tentent de réserver le même créneau simultanément. Sans contrôle approprié de la concurrence, deux utilisateurs peuvent réserver par inadvertance le même créneau, entraînant frustration et conflits.

C'est là que les verrous distribués Redis entrent en jeu. L'utilisation d'un verrou garantit qu'un seul utilisateur peut réserver un créneau à un moment donné.

---

1. Modèles : définition des utilisateurs et des emplacements

Pour commencer, nous devons concevoir nos modèles de données pour les utilisateurs et les emplacements. Ces modèles seront stockés dans MongoDB, et leur structure est simple mais efficace.

un. Modèle utilisateur

Chaque utilisateur possède des attributs de base comme un nom, une adresse e-mail et un mot de passe haché pour l'authentification :

const mongoose = require('mongoose');

const UserSchema = new mongoose.Schema({
    name: { type: String, required: true },
    email: { type: String, required: true, unique: true },
    password: { type: String, required: true },
    createdAt: { type: Date, default: Date.now }
});

module.exports = mongoose.model('User', UserSchema);

b. Modèle de machine à sous

Chaque créneau a une heure de début et de fin, et il permet de savoir s'il a été réservé et par qui :

const mongoose = require('mongoose');

const SlotSchema = new mongoose.Schema({
    startTime: { type: Date, required: true },
    endTime: { type: Date, required: true },
    isBooked: { type: Boolean, default: false },
    bookedBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User', default: null }
});

module.exports = mongoose.model('Slot', SlotSchema);

---

2. Points de terminaison de l'API : comment les utilisateurs interagissent avec le système

Les API sont le pont entre les utilisateurs et le système. Voici les principaux points de terminaison nécessaires :

un. Inscription de l'utilisateur

Permet à un nouvel utilisateur de s'inscrire :

• Point de terminaison : POST /api/users/register
• Demande : Détails de l'utilisateur (nom, email, mot de passe)
• Réponse : Confirmation de l'inscription de l'utilisateur

b. Connexion utilisateur

Authentifie l'utilisateur et fournit un jeton JWT :

• Point de terminaison : POST /api/users/login
• Demande : Identifiants de l'utilisateur (email, mot de passe)
• Réponse : jeton JWT pour l'authentification

c. Créer un emplacement

Permet aux administrateurs ou aux utilisateurs autorisés de créer des emplacements :

• Point de terminaison : POST /api/slots/create
• Demande : Heures de début et de fin des créneaux
• Réponse : Confirmation de création de créneau

d. Fente pour livres

Permet aux utilisateurs de réserver des créneaux disponibles :

• Point de terminaison : POST /api/slots/book/:id
• Demande : jeton JWT dans l'en-tête, ID d'emplacement dans l'URL
• Réponse : Confirmation de réservation de créneau ou erreur (par exemple, si le créneau est déjà réservé)

---

3. Comment fonctionnent les verrous distribués Redis

La

La concurrence est le plus grand défi des systèmes de réservation. Lorsque plusieurs utilisateurs tentent de réserver le même créneau en même temps, Redis vient à la rescousse grâce à ses capacités de verrouillage distribué.

Le processus de réservation avec Redis Locks

1. Acquisition de verrouillage :

   • Lorsqu'un utilisateur tente de réserver un emplacement, le système tente d'acquérir un verrou dans Redis à l'aide de la commande SET lock_key NX EX 10.
   • Le NX (défini s'il n'existe pas) garantit que le verrou n'est créé que s'il n'existe pas déjà, tandis que EX 10 garantit que le verrou expire après 10 secondes (empêchant impasses).
   • Si le verrou est déjà acquis, le système renvoie un statut 423 Verrouillé, informant l'utilisateur que le créneau est en cours de réservation par quelqu'un d'autre.

2. Vérification de la disponibilité des emplacements :

   • Si le verrou est acquis avec succès, MongoDB est interrogé pour vérifier si l'emplacement est toujours disponible (c'est-à-dire non réservé).
   • Si le créneau est disponible, le système met à jour le statut du créneau sur réservé et définit le champ bookingBy sur l'ID de l'utilisateur actuel.

3. Déverrouillage :

   • Une fois le processus de réservation terminé, ou si une erreur se produit, le système libère le verrou en supprimant la clé Redis à l'aide de la commande DEL lock_key.

Exemple de code pour réserver un emplacement avec des verrous Redis :

const mongoose = require('mongoose');

const UserSchema = new mongoose.Schema({
    name: { type: String, required: true },
    email: { type: String, required: true, unique: true },
    password: { type: String, required: true },
    createdAt: { type: Date, default: Date.now }
});

module.exports = mongoose.model('User', UserSchema);

---

4. Gestion des erreurs dans le système de réservation

La gestion gracieuse des erreurs est un élément essentiel de tout système robuste. Voici quelques-unes des erreurs gérées par le système :

• 400 Bad Request : lorsque les données d'entrée ne sont pas valides.
• 404 Not Found : lorsque l'emplacement ou l'utilisateur demandé n'est pas trouvé.
• 423 Verrouillé : Lorsqu'un créneau est actuellement réservé par un autre utilisateur.
• Erreur interne du serveur 500 : pour toute erreur inattendue, telle qu'une défaillance de la base de données ou de Redis.

---

5. Sécuriser le système

La sécurité est essentielle, en particulier lorsque les utilisateurs réservent des ressources. Voici comment le système assure la sécurité :

• Authentification JWT : chaque demande de réservation de créneau nécessite un jeton JWT valide, garantissant que seuls les utilisateurs authentifiés peuvent accéder au système.
• Validation des données : les données saisies sont validées à chaque étape pour empêcher le traitement des données invalides ou malveillantes.
• Expiration du verrouillage : les verrous Redis ont un délai d'expiration intégré (10 secondes) pour éviter les blocages si un processus de réservation échoue à mi-chemin.

---

6. Considérations d'évolutivité

Le système est conçu dans un souci d’évolutivité. À mesure que la demande augmente, les stratégies suivantes peuvent garantir le bon fonctionnement des opérations :

• Redis pour la concurrence : les verrous Redis garantissent que même avec plusieurs instances de l'application en cours d'exécution, les conditions de concurrence sont évitées.
• Redis Clustering : si le système se développe de manière significative, Redis Clustering peut être utilisé pour répartir la charge sur plusieurs nœuds Redis, améliorant ainsi les performances.

---

Conclusion

Créer un Système de réservation de créneaux évolutif et fiable nécessite un examen attentif de la simultanéité, de l'intégrité des données et de la sécurité. En utilisant les verrous distribués Redis, nous pouvons garantir qu'aucun utilisateur ne réserve le même créneau simultanément, éliminant ainsi les conditions de concurrence. De plus, en tirant parti de MongoDB pour la persistance des données et de JWT pour l'authentification, ce système est sécurisé, évolutif et efficace.

Que vous conceviez un système de réservation pour des salles de réunion, des événements ou toute autre ressource limitée dans le temps, cette architecture constitue une base solide pour gérer les réservations de manière fiable sous une charge importante.

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!