Dans un environnement où plusieurs applications serveur à transactions élevées doivent communiquer entre elles, il est important de trouver le meilleur canal de communication pour elles. Un modèle éditeur/abonnement (PubSub) est l'un des moyens les plus populaires lorsqu'il s'agit de fournir une plateforme de communication pour vos applications. Nous savons tous ce que ces médiums ont en commun ; plusieurs clients publient des messages et plusieurs clients peuvent s'y abonner. Tout cela se passe de manière extrêmement découplée, c'est-à-dire que l'éditeur ne déploie pas les messages directement auprès des clients abonnés. Au lieu de cela, un bus de messages est utilisé comme canal intermédiaire par lequel tous les clients communiquent.
En bref, la messagerie PubSub est une méthode dans laquelle ni l'éditeur ni l'abonné ne connaissent l'identité de chacun.
Prenons un moment pour réfléchir à ce qui se passe lorsque le nombre d'éditeurs et d'abonnés augmente. Plus ce nombre est élevé, plus la charge de messagerie sera importante. Cette situation conduit votre plate-forme PubSub à provoquer des goulots d'étranglement en matière d'évolutivité, ce qui va à l'encontre de l'objectif principal de l'introduction d'une interface de messagerie découplée.
Examinons une solution qui non seulement hérite du fonctionnement général de pub/sub, mais y ajoute également un tas d'autres fonctionnalités pour votre confort ; une méthode rapide et extrêmement évolutive.
NCache Détails NCache Pub/Sous-Documents Mise à l'échelle de la messagerie Pub/Sub - Webinaire
En utilisant NCache PubSub en mémoire
NCache vous fournit des caches distribués rapides, flexibles et linéairement évolutifs pour votre application .NET.
En utilisant NCache car votre plate-forme PubSub basée sur les événements peut s'avérer extrêmement bénéfique si vous envisagez de faire évoluer votre application en déplacement. Cela évite tout goulot d’étranglement dans votre système.
Voici comment NCache agit comme un bus de messagerie pour votre application :
NCache agit comme une interface intermédiaire pour votre implémentation Pub/Sub. La figure illustre que non seulement un mais plusieurs clients peuvent s'abonner à un ou plusieurs sujets à la fois.
N'importe quel nombre d'applications peut se connecter au cache et commencer à publier des messages sur le NCache les serveurs. Ces messages sont ensuite souscrits par différents clients en fonction de leurs besoins. Par NCache, vous décidez si tous ou un seul abonné reçoit les messages publiés. En faisant cela, NCache agit comme un bus de messagerie pour vos applications serveur .NET.
NCache Détails Pub / Sous-marin NCache Événements Pub/Sub
Exemple PubSub rapide avec NCache
Supposons que j'ai une application de jeu en ligne utilisée par des joueurs du monde entier. Dans mon application, j'ai une fonctionnalité qui intègre non seulement des communications audio, mais également des messages d'exécution. Plusieurs joueurs envoient des messages contre un canal et pour les joueurs de leur propre équipe en même temps.
Compte tenu du nombre de joueurs jouant au jeu, la charge de messages va être énorme. Ce dont j'ai besoin ici, c'est d'une interface de communication qui booste les performances de mon jeu. Et pour cela, je préfère NCache comme bus de messages de mon jeu.
Voici l'extrait que j'utilise pour implémenter un scénario dans lequel les applications serveur peuvent publier et recevoir des messages. Ce code montre comment vous obtenez un sujet et publiez un message dessus.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// Precondition: Cache is already connected // Get the topic ITopic teamChat = cache.MessagingService.GetTopic("RuntimePlayerComms"); // Create the object to be sent in message // Get information of the player through player ID Player teamLeader = FetchInfo(1); // Create the message var newChatMessage = new Message(teamLeader); // Set the expiration time of the message newChatMessage.ExpirationTime = TimeSpan.FromSeconds(60); // Publish the message with delivery option set to All subscribers teamChat.Publish(newChatMessage, DeliveryOption.All, true); |
Une fois qu'un message a été publié sur un sujet, les abonnés créent des abonnements sur ce sujet pour recevoir des messages. Le code suivant montre comment les applications d'abonnement s'abonnent à une certaine rubrique pour recevoir les messages souhaités.
1 2 3 4 5 6 7 8 9 |
// Precondition: Cache is already connected // Get the topic ITopic teamChat = cache.MessagingService.GetTopic("RuntimePlayerComms"); // Create and register subscribers for the topic // MessageReceived is the callback through which the message is delivered ITopicSubscription subscriber = teamChat.CreateSubscription(MessageReceived); |
NCache Détails Publier des messages Abonnez-vous aux messages
Jusqu'à présent, tout ce dont j'ai parlé était le fonctionnement général du pub/sub, mais ce que vous devez vraiment savoir, ce sont les longueurs supplémentaires qui NCache va répondre à vos besoins.
Vous vous demandez quelles sont ces « autres fonctionnalités » que j'ai précédemment annoncées ? Venons-en directement aux fonctionnalités offertes exclusivement par NCache.
Abonnements durables exclusifs
Normalement, lorsqu'un client s'abonne à un sujet, cet abonnement est appelé abonnement non durable, ce qui signifie que si le client se déconnecte du serveur, tous ses abonnements sont perdus.
NCache vous fournit des abonnements durables. Dans ce cas, même si la connexion entre le serveur et le client est interrompue, tous les abonnements de ce client restent intacts. Ainsi, lorsque le client se reconnecte, il reçoit tous les messages qui ont été publiés alors que l'abonné était déconnecté.
La façon dont vous exécutez ce scénario dans votre application est simple. Vous ajoutez la ligne de code suivante dans votre application pour implémenter un abonnement durable exclusif.
1 2 3 4 5 6 7 8 |
// Create and register subscribers for the topic // MessageReceived callback is specified // The subscription policy is Exclusive IDurableTopicSubscription subscriber = teamChat.CreateDurableSubscription("RuntimePlayerComms", SubscriptionPolicy.Exclusive, MessageReceived, TimeSpan.FromMinutes(20)); |
Tant que la connexion est active, aucun nouveau client ne peut souscrire à cet abonnement. Si cette connexion est interrompue, les messages sont conservés et lorsque la connexion est rétablie, ils sont envoyés au client. Ceci est fait pour qu'aucun message ne soit perdu.
NCache Détails Pub / Sous-marin NCache Abonnements durables
Abonnements durables partagés
Outre les abonnements exclusifs, la durabilité peut également être obtenue grâce à des abonnements partagés. Dans ce type d'abonnement, plusieurs clients peuvent souscrire à un même abonnement. Cela sert l'objectif du partage de charge.
Les abonnements partagés utilisent la méthode Round Robin pour envoyer des messages à tous les clients connectés. Ainsi, même si un client est déconnecté, les messages continuent d'être distribués parmi les abonnés restants.
Un abonnement reste actif aussi longtemps qu'un seul client y est connecté. Le code suivant explique comment mon application de jeu en ligne implémente des abonnements durables partagés.
1 2 3 4 5 6 7 8 9 |
// Create and register subscribers for the topic // MessageReceived callback is specified // The subscription policy is Shared IDurableTopicSubscription subscriber = teamChat.CreateDurableSubscription("RuntimePlayerComms", SubscriptionPolicy.Shared, MessageReceived, TimeSpan.FromMinutes(20)); |
Par défaut, ces abonnements sont exclusifs et autorisent exactement un abonné par abonnement.
Abonnements basés sur des modèles
Parfois, au lieu de souscrire à des abonnements nommés un par un, un modèle est fourni sous lequel tous les sujets, présents et à venir, sont souscrits en une seule fois. Pour accommoder cela, NCache facilite ses clients en fournissant des abonnements basés sur des modèles. Grâce à cette méthode, un sujet ou plusieurs sujets qui relèvent du modèle fourni peuvent être facilement souscrits.
Pour connaître les types de caractères génériques pris en charge par NCacheles abonnements PubSub de, veuillez vous référer à NCache documentation sur Abonnements basés sur des modèles.
Voici un exemple d'extrait de la façon dont j'utilise des caractères génériques basés sur des modèles dans mon application de jeu.
1 2 3 4 5 6 |
// Only ? * [] wildcards supported string topicName = "team*"; string subscriptionName = "TeamPlayersComms"; // Get the topic ITopic teamChat = cache.MessagingService.GetTopic(topicName, TopicSearchOptions.ByPattern); |
Constat NCache pour PubSub ?
Pourquoi privilégier NCache, vous pourriez demander? Hé bien… NCache is
- rapide car il s'agit d'une solution en mémoire.
- linéairement évolutif car vous pouvez ajouter des serveurs supplémentaires au moment de l'exécution ; à toute heure.
- flexible car il rééquilibre automatiquement les données de manière dynamique sans aucune intervention du client.
La façon dont je le vois, NCache fournit le moyen le meilleur, le plus évolutif et le plus rapide pour gérer la communication des messages au sein de votre application. Le fait que NCache est une solution de mise en cache distribuée en mémoire suffisante pour contrer tout goulot d'étranglement pouvant survenir en raison de la charge des messages. Maintenant, c'est la situation gagnant-gagnant dont vous avez besoin dans votre application .NET.