Mise à l'échelle ASP.NET Core Applications avec NCache
Webinaire enregistré
Par Ron Hussain et Zack Khan
ASP.NET est une technologie très populaire pour le développement d'applications Web. Maintenant sa dernière version ASP.NET Core gagne rapidement en popularité auprès des organisations soucieuses de migrer leurs applications Web vers ASP.NET Core. Mais, ASP.NET Core se heurte à des problèmes d'évolutivité et de performances lorsqu'il est soumis à une charge utilisateur importante. Cela se produit parce que votre stockage de données devient un goulot d'étranglement. Cependant, il existe un moyen de contourner ce goulot d'étranglement en termes de performances et d'évolutivité si vous utilisez la mise en cache distribuée. Découvrez comment vous pouvez optimiser votre ASP.NET Core performances et évolutivité pour fonctionner sous des charges de transaction extrêmes.
Voici ce que couvre ce webinaire :
- Présentation de l'ASP.NET Core évolutivité et goulots d'étranglement des performances
- Comment la mise en cache distribuée résout ces problèmes
- Mise en cache des données d'application via ASP.NET Core Interface IDistributedCache et Direct NCache Apis
- ASP.NET Core Stockage de session avec NCache
- ASP.NET Core Mise en cache des réponses avec NCache
- Certains importants NCache fonctionnalités de cache distribué
Dans le webinaire d'aujourd'hui, nous allons faire un aperçu de l'ASP.NET Core l'évolutivité et les goulots d'étranglement des performances et comment la mise en cache distribuée résout ces goulots d'étranglement et d'autres problèmes. Nous allons parler d'ASP.NET Core applications, quels sont leurs goulots d'étranglement en termes de performances et d'évolutivité, puis nous verrons comment résoudre ces goulots d'étranglement en termes de performances et d'évolutivité à l'aide de NCache système de cache distribué.
NCache est un système de mise en cache distribué en mémoire pour votre .NET et .NET Core applications. Il est écrit en .NET et principalement pour .NET et .NET Core applications, mais aujourd'hui, l'accent sera principalement mis sur ASP.NET Core applications Web et j'ai quelques exemples de fonctionnalités disponibles. J'ai également aligné quelques exemples d'applications. Il s'agira donc d'un webinaire pratique où je partagerai certains détails au niveau des fonctionnalités de différents cas d'utilisation que vous pouvez capturer et des fonctionnalités qui sont là pour aider à résoudre ces cas d'utilisation et je démontrerai également ces exemples. Commençons.
Ainsi, nos premières diapositives sont des diapositives d'introduction sur ASP.NET Core plate-forme en général. Je suis sûr que tout le monde sait ce qu'est l'ASP.NET Core est. C'est la nouvelle plate-forme d'applications Web ASP. C'est propre, léger, modulaire. C'est principalement l'architecture MVC, en ce qui concerne l'approche des applications Web. Vous savez, le populaire front-end Angular, React, c'est principalement un front-end basé sur JavaScript, puis une architecture MVC pour le sauvegarder. C'est multiplateforme. Vous pouvez l'exécuter sur Windows, Linux et tout autre système d'exploitation, tel que macOS. Et, généralement, c'est quelque chose qui est également très compatible avec les applications ASP.NET 4.0 héritées.
Si vous avez une application ASP.NET MVC, vous pouvez maintenant migrer à partir de celle-ci, puis commencer à utiliser ASP.NET Core technologie d'ailleurs, qui est très rapide, très robuste et très légère et propre à l'architecture, en général.
Qu'est-ce que l'évolutivité?
La première chose que nous allons parler d'ASP.NET Core plate-forme est-il nécessite une évolutivité. Alors, définissons ce qu'est l'évolutivité ? Toute application qui s'exécute sous une charge utilisateur normale et par normalisation, je veux dire que certains utilisateurs sont là. Disons que 5 à 10 utilisateurs sont connectés et qu'ils effectuent certaines transactions, certaines opérations, des demandes de lecture et d'écriture. L'idée typique ici est que votre application serait ultra-rapide avec une faible charge utilisateur. Mais, dès que la charge de votre application augmente et c'est quelque chose qui est également une exigence pour l'entreprise, vous devez avoir de plus en plus d'utilisateurs se connectant à vos applications. C'est alors que vos applications ont tendance à ralentir. Il pourrait y avoir des performances lentes sous des charges de pointe.
Si votre application n'est pas en mesure de maintenir les mêmes performances qu'elle avait avec un faible nombre d'utilisateurs, puis lorsqu'elle a le nombre élevé d'utilisateurs si elle est capable de maintenir les mêmes performances, cette application serait classée comme une application très évolutive. L'architecture a cette capacité à évoluer et à gérer la charge accrue de vos utilisateurs finaux. Ainsi, des performances élevées sous des charges de pointe sont ce qui définit réellement le facteur d'évolutivité.
Voici un graphique. En règle générale, l'évolutivité est obtenue dans ASP.NET et ASP.NET Core plate-forme via plusieurs serveurs Web ou d'applications.
Vous pouvez répartir la charge de votre application. Vous déployez simplement votre application sur plusieurs serveurs Web ou d'applications et, sur cette base, vous distribuez simplement la charge utilisateur de votre application sur ces serveurs et, à mesure que vous ajoutez des serveurs, vous obtenez une amélioration linéaire de la capacité de traitement des demandes. Plus de serveurs signifie plus de capacité de traitement des demandes de votre application.
Voici une évolutivité non linéaire où même après avoir ajouté plus de serveurs, l'architecture n'est pas conçue de telle manière que même si vous ajoutez beaucoup de serveurs Web ou de serveurs d'applications, vos applications ne sont pas évolutives, car votre charge utilisateur est croissance.
Ainsi, vos besoins en transactions augmentent et vous ajoutez des serveurs, vous faites toutes les bonnes étapes, mais vous n'êtes toujours pas en mesure d'obtenir la capacité dont vous avez besoin pour répondre à la charge accrue de demandes. Donc, ce problème est généralement associé aux sources de données principales et je vais en parler.
Alors, tout d'abord, voyons quelles applications ont besoin d'évolutivité. Quels sont les différents types d'applications ? Dans ASP.NET & .NET Core nous avons des applications Web et des applications Web MVC, exécutant l'activité principale, certains services Web, certains appels de service, certains microservices, c'est la nouvelle architecture et cela pourrait être n'importe quel autre .NET général ou .NET Core Application.
Tous ces éléments exigent une évolutivité, car vous pouvez avoir de nombreux utilisateurs internes ou externes ou demander une charge qui doit être satisfaite par l'architecture de votre application.
Le problème de l'évolutivité
J'ai mentionné que vous pouvez créer une ferme Web. Vous pouvez répartir la charge de votre application sur plusieurs serveurs. Alors, où se situe exactement le problème d'évolutivité ? Comme vous pouvez le voir, si vous ajoutez des serveurs, vous devriez être en mesure de gérer de plus en plus de charge de requêtes, car cela vous donne une évolutivité linéaire en ce qui concerne la batterie d'applications ou la batterie Web.
Mais, quand exactement commencez-vous à voir une évolutivité non linéaire ou pas d'évolutivité du tout ? C'est généralement le cas avec les bases de données relationnelles. Votre niveau d'application évolue bien, n'est-ce pas. Vous pouvez ajouter plus de serveurs. Vous pouvez créer plusieurs instances de la même application sur le même boîtier ou disposer de boîtiers distincts hébergeant vos applications. Mais toutes ces applications parlent normalement à une base de données relationnelle backend et la base de données relationnelle est très bonne pour le stockage, mais lorsqu'il s'agit de gérer une quantité extrême de charge de requêtes, par exemple, vous avez beaucoup de charge transactionnelle sur vos applications, cette base de données devient un goulot d'étranglement. Cela va tout d'abord ralentir les choses, donc, c'est un goulot d'étranglement des performances et ensuite il n'a pas la capacité d'augmenter l'évolutivité de celui-ci. Il n'a aucune possibilité d'augmenter la capacité. Cela vous donnerait simplement la capacité du serveur donné où la base de données est hébergée.
Il pourrait également s'agir d'une base de données mainframe. Il pourrait s'agir d'un système de fichiers. Toutes ces sources constituent un goulot d'étranglement pour l'évolutivité de votre application et c'est là que vos applications ralentissent. Vos demandes commencent à faire la queue et l'expérience globale de l'utilisateur final en est affectée. NoSQL n'est pas la réponse. Vous savez, je comprends que beaucoup de NoSQL les produits sont là. Nous avons également un produit appelé NosDB, Qui est un NoSQL database. Mais le principal problème avec NoSQL databases est que vos applications nécessiteraient une ré-architecture, où vous arrêtez d'utiliser une base de données relationnelle et commencez à utiliser une NoSQL source de données non structurées en comparaison.
Donc, la ré-architecture de l'application n'est pas facile non plus, n'est-ce pas. Donc, c'est un autre problème que vous devez prendre. Ainsi, dans l'ensemble, vos applications ne sont pas évolutives, principalement en raison des sources de données principales.
La solution: NCache Cache distribué
Quelle est la solution? C'est très simple, que vous commenciez à utiliser un système de mise en cache distribué comme NCache. C'est en mémoire, donc c'est super rapide par rapport à la base de données. Donc, c'est le premier avantage que vous en retirez. Ainsi, avec un accès en mémoire, par rapport à un accès sur disque NCache est super rapide en comparaison. Alors, premier avantage, vos demandes de candidature régulières vont à NCache par rapport à la base de données, ils vont être ultra-rapides et vont également alléger la charge de la base de données en évitant les déplacements vers les sources de données principales. Ainsi, votre base de données est également libre de faire d'autres choses. Le deuxième avantage est qu'il est très évolutif. Il est linéairement évolutif dans son modèle. Ce n'est pas qu'un seul serveur. Il existe plusieurs serveurs que vous pouvez utiliser pour héberger votre cluster de cache. C'est un cluster de cache. Ainsi, l'équipe de serveurs travaille en combinaison les uns avec les autres et aide à répondre aux demandes de vos clients. Plus de serveurs signifie plus de capacité de traitement des demandes sur NCache et c'est là que cela vous donne d'énormes avantages, où non seulement vous obtenez des réponses ultra-rapides de NCache, il est ultra-rapide, à faible latence et vous offre également un débit élevé et une évolutivité extrêmement élevée. Vous pouvez continuer à ajouter plus de serveurs et vous pouvez augmenter cette capacité de manière linéaire chaque fois que votre charge utilisateur augmente, sans rien changer à l'intérieur de votre architecture d'application.
Et, bonne chose à propos de NCache est que vous l'utilisez en plus d'une base de données principale. Il ne s'agit pas d'un remplacement de vos sources de données relationnelles conventionnelles. Nous n'avons pas besoin de ré-architecturer l'application pour commencer à utiliser NCache. Vous pouvez toujours utiliser NCache en combinaison avec une source de données back-end, dans laquelle se trouvent une partie ou la plupart de vos données NCache et la base de données en a une copie maîtresse. Mais, pour certains cas d'utilisation, le cache contiendrait toutes les données. Par exemple, pour les sessions et pour d'autres cas d'utilisation.
NCache Chiffres d'évolutivité
Voici nos chiffres de débit. Nous avons effectué ces tests dans notre laboratoire AWS. Il s'agissait de données d'application réelles, simulées dans notre laboratoire AWS. Donc, ce ne sont pas des données tactiles. Données d'application réelles simulées, dans notre environnement. Où nous avons utilisé 5 NCache serveurs et nous avons pu atteindre 2 millions de requêtes par seconde sur NCache.
Donc, c'est le genre d'améliorations de performances que vous avez si vous ou les chiffres d'évolutivité que vous avez, si vous avez de plus en plus de serveurs ajoutés. Ainsi, 2 millions de requêtes par seconde avec seulement 5 NCache serveurs et c'était une tendance à la hausse très linéaire et elle devrait continuer à augmenter, si vous continuez à ajouter plus de serveurs.
Ceux-ci sont également publiés sur notre site Web. Il y a un démonstration vidéo également disponible.
Architecture de déploiement
Voici notre architecture de déploiement. Typiquement, c'est ainsi NCache système de mise en cache distribué est déployé. Il est pris en charge sur tous les environnements sur site ainsi que dans le cloud. Vous pouvez, vous avez juste besoin que .NET ou NET Core Framework soit disponible. C'est le seul prérequis pour NCache et vous pouvez le déployer sur Windows ainsi que sur des serveurs Linux. Il peut s'agir de vos boîtes physiques ou virtuelles sur site ou de n'importe quel cloud public ou privé, où vous avez .NET ou .NET Core installé sur Windows ou Linux. Donc, ce sont deux exigences.
Autre que ça NCache est pris en charge sur toutes les plates-formes. Il est disponible en Azure Marketplace, ainsi qu'AWS et nous proposons également un modèle ou un déploiement basé sur SaaS de NCache dans nos prochaines versions.
Il existe deux options de déploiement. La première est que vous devez utiliser des serveurs dédiés pour la mise en cache et que vos applications se connectent dans un modèle client-serveur. C'est également le modèle préféré dans le cloud où vous n'avez pas de machines virtuelles côté client, mais vous avez un déploiement côté serveur.
Et, la deuxième option de déploiement est que vous utilisez vos boîtes d'application existantes comme votre NCache les serveurs aussi. C'est principalement sur site où vous avez déjà le niveau d'application. Des configurations plus petites, vous voudrez peut-être utiliser NCache à installer sur le même boîtier, même ensemble de serveurs.
De toute façon NCache gère la majeure partie de votre trafic. 100% est recommandé et une partie du trafic peut toujours aller vers la base de données principale et cela pourrait être vos opérations transactionnelles de lecture, d'écriture que vous pouvez gérer via le cache vers les sources de données principales.
Ainsi, vous pouvez soit utiliser le cache comme modèle de site où votre application contient des données et met à jour des données ou récupère des données à partir du cache et de la base de données en conjonction, ou vous pouvez utiliser une approche de lecture et d'écriture qui est également disponible avec NCache.
Utilisations courantes du cache distribué
Je parlerai de quelques cas d'utilisation, puis nous passerons directement à notre ASP.NET Core mise en cache spécifique fonctionnalités. Parlons donc de quelques cas d'utilisation courants de NCache. Il existe de nombreux cas d'utilisation. Et, d'un point de vue technique, j'en ai énuméré quelques-uns et ceux-ci sont spécifiques à ASP.NET Core applications, mais en général pour tout .NET ou ASP.NET ou ASP.NET Core or .NET Core. Il peut s'agir d'une application Web, d'une application back-end, de certains flux de travail, de certains services Windows, n'importe quelle application peut utiliser NCache et vous pouvez choisir parmi de nombreux cas d'utilisation.
-
Mise en cache des données d'application
Principalement, pour ASP.NET Core, nous allons cibler la mise en cache des données de l'application et en cela, nous avons deux options. Vous pouvez utiliser Interface IDistributedCache. Si vous utilisez déjà IDistributedCache dans vos applications, vous pouvez simplement brancher NCache en tant que fournisseur pour cela. Donc, c'est la première option. La deuxième option est que vous utilisez direct NCache Les API et la mise en cache des données d'application vous permettent de mettre en cache presque tout dans votre application. Il peut s'agir de vos objets de domaine, de vos collections, de vos ensembles de données, de toutes les données que vous souhaitez utiliser plus d'une fois et que vous ne souhaitez pas accéder à la base de données principale, vous avez récupéré ces données et maintenant vous pouvez les conserver dans le cache et vous pouvez continuer à utiliser le référentiel de cache et enregistrer des déplacements vers la base de données.
ASP.NET Core Mise en cache de session et SignalR Backplane
Le deuxième cas d'utilisation est ASP.NET Core cache spécifique. Ce sont nos fonctionnalités de mise en cache frontale Web. Sur ce front, nous avons beaucoup de fonctionnalités. Vous pouvez utiliser ASP.NET Core état de session. Vous savez, il s'agit de sessions mono-site et multi-sites. NCache est un cluster de cache distribué. Ainsi, vos sessions sont stockées de manière distribuée à l'intérieur NCache. C'est aussi une option sans changement de code, presque avec une ligne de changement de code dans la méthode d'extension où vous vous connectez NCache. Aucune modification importante du code n'est nécessaire pour l'utiliser et ceux-ci sont très fiables à l'intérieur NCache car les sessions sont répliquées sur les serveurs. Ainsi, tout serveur tombant en panne n'aurait aucune perte de données ni aucun temps d'arrêt d'application de votre côté.
La deuxième caractéristique ici est ASP.NET Core mise en cache des réponses. Si vous avez des pages statiques. Historiquement, dans ASP.NET, nous avions une mise en cache de sortie. Dans le nouvel ASP.NET Core plate-forme, vous pouvez utiliser la mise en cache des réponses, où vous définissez les en-têtes au niveau de la page et sur la base de ces pages, toutes les sorties de page sont mises en cache à l'intérieur NCache. Ainsi, les réponses sont mises en cache. Si vous émettez à nouveau exactement les mêmes demandes, vous obtenez la réponse pré-cachée disponible. Donc, c'est une caractéristique dans NCache, qui est également une option sans changement de code que vous pouvez utiliser sur ASP.NET Core niveau de cache frontal.
Et puis, si vous utilisez SignalR et si vous avez une ferme Web, vous avez besoin d'un fond de panier indispensable. Alors, SignalR Backplane est requis si vous passez d'un serveur unique à un déploiement de ferme Web et dans ce cas NCache peut agir en tant qu'ASP.NET Core Fond de panier, SignalR Backplane pour vos applications SignalR. Il utilise la messagerie Pub/Sub en arrière-plan, qui est pilotée par les événements. Très rapide, très évolutif. Ainsi, vous bénéficiez de performances et d'une évolutivité élevées, ainsi que d'une disponibilité et d'une fiabilité élevées, si vous branchez NCache en tant qu'ASP.NET Core SignalR Backplane.
Messagerie Pub/Sub
Enfin, le troisième cas d'utilisation est la messagerie Pub/Sub. Messagerie Pub/Sub est également un cas d'utilisation distinct. Pour SignalR, les coulisses que nous utilisons sont la messagerie Pub/Sub. Mais la messagerie Pub/Sub peut être utilisée comme un cas d'utilisation distinct dans NCache aussi bien. Pour les applications Microservices, cela a beaucoup de sens, où vous avez des applications simples définies sous l'architecture Microservices. Ceux-ci sont chargés d'une tâche dédiée. Un objectif très important qu'ils servent. Il est donc très difficile d'organiser la communication entre ces microservices et NCache peut résoudre ce problème. Vous n'avez pas besoin d'implémenter vous-même une communication au sein de vos applications Microservices. Vous pouvez compter sur NCache plate-forme de communication pour cela et toute application qui y est connectée peut envoyer et recevoir des messages et il n'a pas à subir de dégradation des performances pendant qu'ils le font.
Vous pouvez avoir un modèle d'abonné éditeur. Où les éditeurs publient des données dans le cache, puis le cache stocke et relaie ces messages à tous les abonnés. Il s'agit d'un mécanisme piloté par les événements asynchrones. Ainsi, l'éditeur et les abonnés n'ont même pas besoin de se connaître. Ainsi, il n'y a pas de latence, pas d'attente impliquée, pas d'appels synchrones impliqués. Donc, c'est une architecture très robuste, très rapide, faiblement couplée et tout est géré par NCache, en ce qui concerne cette plate-forme.
Démonstration pratique
Nous avons donc couvert ces fonctionnalités de haut niveau. Ensuite, je vais vous montrer le produit réel en action. Où je vais créer un cluster de cache. Essaye-le. Vous montrer quelques aspects de la surveillance puis nous parlerons de toutes ces fonctionnalités que vous pouvez utiliser en ASP.NET Core un par un. J'ai donc aligné quelques exemples d'applications pour cela. Je me connecte donc à mon environnement de démonstration.
Donc, ici, nous avons deux NCache serveurs que j'utiliserai et ma machine agirait comme une machine cliente à partir de laquelle j'exécuterais tous ces exemples d'applications. Donc, l'idée ici est que je vais utiliser le outil de gestion et outil de surveillance en ligne.
Ainsi, cet outil de gestion basé sur le Web vous permet de tout gérer et de surveiller à partir d'un seul point. Il peut s'agir de n'importe quelle requête Web, requête http de n'importe où, de votre environnement à l'un de vos NCache serveurs ou clients et cela devrait vous permettre de tout gérer et surveiller à distance via le Web.
Créer un cache en cluster
Ainsi, localhost, vous pouvez donner une adresse IP et vous pouvez simplement accéder à cette ressource de n'importe où sur Internet. Donc, je vais continuer et créer un nouveau cache. Disons, 'aspcorecache'. Tous les caches doivent être nommés. Vous pouvez également créer plusieurs clusters de cache et vous pouvez trouver n'importe quel nom de cache significatif selon vos besoins.
Le mode de sérialisation peut être binaire ou JSON. Donc, je vais m'en tenir au binaire, m'en tenir au binaire, puis JSON est également très flexible, donc, si vous souhaitez l'utiliser, je choisirai la partition de la topologie du cache de réplique.
Dans NCache il y a beaucoup de topologies de mise en cache. Si je vous emmène rapidement vers la fin. Nous avons donc le choix entre de nombreuses topologies de mise en cache. Nous avons partitionné, puis nous avons partitionné avec des sauvegardes. Donc, dans ce cas, chaque serveur maintient deux partitions. Une partition de données active, où les clients sont connectés et une partition de réplique passive d'un autre serveur. Comme vous pouvez le voir, le service un est actif, sa sauvegarde est sur deux et le serveur deux est actif, sa sauvegarde est sur le serveur un. En cas de panne d'un serveur, la sauvegarde est activée et vous obtenez toutes les données à partir d'ici. Dans des opérations normales, ces partitions ont une distribution égale des données.
Les clients sont connectés à tous les serveurs, donc les demandes de lecture et d'écriture sont super rapides et si vous ajoutez plus de serveurs, vous obtenez plus de capacité de traitement des demandes de lecture et d'écriture car tous ces serveurs fonctionnent en combinaison les uns avec les autres. C'est donc la topologie que je choisis pour la partition de la réplique.
Et puis l'option de réplication asynchrone. Entre actif et sauvegarde, vous pouvez choisir sync ou async. La synchronisation est plus fiable. Async est plus rapide. Donc, je vais continuer avec ça.
La taille 1024 est assez bonne pour cette démo, mais vous pouvez trouver n'importe quelle taille qui vous semble significative.
Paramètres TCP.
Question: Nous utilisons actuellement NCache, existe-t-il un moyen d'éviter un fichier client.ncc ou nc conf ou quelque chose que vous avez dans votre pipeline de développement ?
Oui. C'est tout à fait possible. client.ncconf vous permet de spécifier des configurations pour vous connecter à un serveur de cache, où le cluster de cache est en cours d'exécution, à droite. Dans mon cas, j'ai deux boîtes et un nom de cache. Ainsi, client.ncconf contient le nom du cache et les serveurs sur lesquels ce cache est configuré. Si vous voulez éviter client.ncconf, vous pouvez fournir tous ces paramètres en ligne. Nous avons des paramètres d'initialisation du cache. Nous les appelons cache init params. Ce sont cet objet qui vous permet de spécifier toutes ces configurations dans le code de l'application. Donc oui. Pour répondre à cette question, vous devez utiliser les paramètres d'initialisation du cache.
Question: Pouvons-nous déployer NCache dans Azur ?
Absolument. J'en ai discuté lorsque nous partagions des détails sur l'architecture de déploiement. NCache est entièrement pris en charge dans Microsoft Azure et AWS et tout autre cloud public ou privé. Uniquement prérequis pour NCache est .NET ou .NET Core, dépendent du système d'exploitation que vous choisissez. Nous proposons également notre modèle SaaS au sein d'Azure et d'AWS. Donc, il est entièrement pris en charge. L'image de notre place de marché est également publiée. Il existe donc de nombreuses façons d'utiliser NCache en azur.
NCache est un protocole de clustering de cache basé sur TCP/IP. Il nécessite donc une adresse IP et un port. Donc, je vais juste garder tout par défaut sur l'écran.
Si mon cache est plein, j'ai deux options, je peux rejeter les nouvelles mises à jour et continuer à utiliser le cache pour la lecture ou je peux activer les expulsions et cela supprimerait automatiquement certaines données pour faire de la place pour les nouveaux éléments.
Pour les sessions, pour l'état d'affichage, pour la mise en cache des réponses et même pour la mise en cache des objets, si les données sont de nature importante, je vous recommande fortement de désactiver l'éviction et de fournir une taille de gaz suffisamment grande pour qu'elle ne devienne jamais pleine et même si elle devient pleine vous pouvez modifier la taille du cache lors de l'exécution. Mais, si c'est acceptable de se permettre, il est acceptable de perdre des données, si vous pouvez vous le permettre, donc, dans ce cas, vous pouvez activer les expulsions et lorsque le cache devient plein, il supprimera automatiquement certaines données et fera de la place pour les nouvelles données. Donc, c'est ce que fait l'expulsion.
Démarrez ce cache à la fin et démarrez automatiquement ce cache au démarrage du service. Ainsi, chaque fois que mon serveur est redémarré, le cache est automatiquement démarré et c'est tout. C'est aussi simple que cela de configurer un cluster de cache à deux nœuds avec NCache.
Simuler le stress et surveiller les statistiques du cache
Donc, notre cache est opérationnel. Il est également activé, donc je vais rapidement aller de l'avant et le tester. Fenêtre des statistiques. Donc, ceux-ci me montrent les compteurs perfmon des deux serveurs, puis surveillent les aspects de NCache.
Très bien. Ainsi, cela me donne également une vue de rapport de tableau de bord côté serveur et côté client. Donc, tous les paramètres sont là.
La prochaine chose est de tester ce cache. Aucune application n'est connectée, je vais donc continuer et le faire. C'est le nom du cache et dans les coulisses, cela utilise des configurations côté client pour se connecter et se connecterait à mon cluster de cache et commencerait à simuler des requêtes. Comme vous pouvez le voir, le compteur Requêtes par seconde et le compteur Moyenne de microsecondes par opération de cache affichent l'activité. Nous avons également des ajouts, des extractions, des mises à jour et nous avons un compteur de taille de cache qui s'affiche, un processeur, une mémoire et nous avons des adresses IP client qui sont actuellement connectées au cache.
Permettez-moi d'aller de l'avant et d'exécuter une autre instance de cet outil.
Question: Une autre question, pendant que vous faisiez cela, est-ce que nous pouvons surveiller tous les clients connectés à nos caches ?
Absolument. C'est l'une des fonctionnalités très puissantes de NCache. Je peux le montrer à l'aide de cet exemple. Maintenant que nous avons deux clients connectés. Tout d'abord, je peux voir les tableaux de bord des clients. Ainsi, ces deux clients sont exécutés à partir de 107 et je peux voir des opérations de lecture effectuées à partir de cette boîte client. Si j'exécute des applications à partir de ma boîte, ce que je ferais, vous verrez également les statistiques de ma boîte ici et de la même manière, nous pouvons également voir les processus, leurs ID de processus, les ports, les octets envoyés et reçus à partir d'ici également. Mais, je pense que la principale chose que vous recherchez est des aspects de surveillance différents du côté client. Donc, nous avons des opérations de lecture par seconde, des ajouts par seconde, des mises à jour par seconde, des récupérations.
Ainsi, nous avons un ensemble complet de compteurs côté client, qui sont disponibles dans le cadre de NCache, à droite et Santé du cache et ce sont tous des compteurs côté serveur, mais tous ces compteurs, que vous affichez sous côté client, peuvent être ajoutés et vous pouvez également les consulter pour vos serveurs d'applications client.
Alors, NCache est très étendu dans sa prise en charge de la surveillance côté client. J'espère que cela répond à votre question.
Maintenant, j'ai exécuté en fait, je suis capable d'exécuter deux instances de l'outil de test de stress et vous pouvez voir environ 800 à 900 requêtes par seconde par chacune NCache serveur. Ainsi, environ 1500 requêtes par seconde en moyenne sont traitées.
Donc, c'était une démo rapide. Je vais arrêter ces outils. Ensuite, je vais vous montrer les fonctionnalités réelles que vous pouvez réellement utiliser. Donc, nous avons passé beaucoup de temps à expliquer comment NCache est très évolutif.? Comment est-il déployé ? Comment configurer et créer un cluster de cache ?
Maintenant, la prochaine chose que je voudrais souligner est la façon d'utiliser NCache en ASP.NET Core applications et quels sont les principaux cas d'utilisation. Nous avons couvert différents cas d'utilisation. Donc, je vais commencer avec les cas d'utilisation de la mise en cache frontale Web dans ASP.NET Core.
NCache ASP.NET Core Mise en cache des sessions
Donc, la première caractéristique que je vais souligner est NCache ASP.NET Core mise en cache des sessions. Nous avons deux options ici. Vous pouvez utiliser, si vous utilisez déjà des sessions et la plupart des chances sont que vous utiliseriez l'interface IDistributedCache. Ainsi, vous pouvez brancher NCache en tant que fournisseur pour la mise en cache de session via IDistributedCache. Vous avez un fournisseur autonome en mémoire. Vous avez un fournisseur de serveur SQL. Standalone est un point de défaillance unique. Ce n'est pas évolutif. Le serveur SQL est également un point de défaillance unique dans certains cas. Ce n'est pas évolutif et c'est très lent.
NCache le fournisseur est super rapide. C'est en mémoire. C'est très évolutif. Il ne s'agit pas d'un point de défaillance unique et vous augmentez la capacité au moment de l'exécution. Ainsi, vous pouvez avoir de plus en plus de serveurs ajoutés et vous pouvez savoir atteindre une évolutivité illimitée sur NCache. Donc, IDistributedCache, passons rapidement en revue cela. Alors, voici notre jeu de devinettes, IDistributedCache.
public void ConfigureServices(IServiceCollection services)
{
//Add framework services
services.AddMvc();
services.AddNCacheDistributedCache(configuration =>
{
configuration.CacheName = "MyNCacheCache";
configuration.EnableLogs = true;
configuration.ExceptionsEnabled = true;
});
}
public void Configure(IApplicationBuilder app)
{
app.UseNCacheSession();
}
Tout ce que vous avez à faire est d'ajouter des services NCache Distributed Cache, puis dites app Use NCache Session et voici un exemple d'application qui va faire exactement cela.
public IConfigurationRoot Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
//To test sessions with NCache Distributed Cache, uncomment the following lines and comment the line after it
services.AddNCacheDistributedCache(Configuration.GetSection("NCacheSettings"));
services.AddSession();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();La deuxième option ici est NCache fournisseur de session qui a des fonctionnalités avancées et j'ai également un exemple d'application pour cela. Alors, concentrons-nous vraiment sur cela. Principalement, parce que notre fournisseur est beaucoup plus riche en fonctionnalités par rapport à IDistributedCache, je voudrais donc souligner cela et dans le cadre de cela, vous verrez toutes les fonctionnalités que le fournisseur IDistributedCache vous offre également.
Alors, reviens ici. Tout d'abord, vous avez besoin NCache Package NuGet, que j'ai déjà ajouté à l'intérieur de celui-ci. Donc, si nous avons AspNetCore.Sessions.NCache, à droite. Donc, c'est le package NuGet et permettez-moi de revenir rapidement ici et de passer en revue la session ici aussi et cela a NCache.Microsoft.Extensions.Caching. Ainsi, les packages NuGet de session IDistributedCache sont légèrement différents des NCache fournisseur de session réel.
Donc, je vais me concentrer sur celui-ci ici. Tout ce que vous avez à faire est de…. Tout d'abord, venez sur Startup.cs. Vous avez des services.AjouterNCacheSession et il faut NCache paramètres dans la configuration.
...
public IConfigurationRoot Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
//To test sessions with NCache Distributed Cache, uncomment the following lines and comment the line after it
//services.AddNCacheDistributedCache(Configuration.GetSection("NCacheSettings"));
//services.AddSession();
services.AddNCacheSession(Configuration.GetSection("NCacheSettings"));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
... Et, à l'intérieur de la configuration, vous spécifiez tout NCache paramètres du fournisseur. Par exemple, j'utilise ASP.NET Core cache. SessionAppId est un attribut d'ID d'application auquel l'application est ajoutée avec la clé de l'élément de cache. Votre identifiant de session devient la clé de cache et cet attribut y sera ajouté. Ainsi, vous pouvez visualiser de manière unique les sessions de différentes applications à l'intérieur NCache puis vous configurez un verrouillage de session. Vous pouvez, si vous le définissez sur true. Très bien, donc, si vous réglez ceci sur true, cela vous permettrait simplement de verrouiller la session, de sorte que l'accès simultané ne soit pas autorisé.
{
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"Default": "Debug",
"System": "Information",
"Microsoft": "Information"
}
},
"NCacheSettings": {
"CacheName": "mycache", //Replace "myPartitionedCache" with the name of your cache
"SessionAppId": "GuessGame", //(Optional)Specifies an identifier to make sure that session ID remains unique in case multiple applications are using the same cache.
"EnableSessionLocking": false, //(Optional)If this flag is set, NCache Session Store Provider exclusively locks the session-store item for which multiple concurrent requests are made. The default is false.
"SessionLockingRetry": -1, //(Optional)If enableSessionLocking is true and this integer is not less than 0, NCache Session Store Provider will return empty session after sessionLockingRetry, which specify the number of retries to acquire a lock. The default is -1.
"EnableLogs": false, //(Optional)When this flag is set, store provider logs all error information. The log files are created in %NCHOME%/log-files/SessionStoreProvider. The default is false.
"EnableDetailLogs": false, //(Optional)When this flag is set, store provider logs all debugging information. The log files are created in %NCHOME%/log-files/SessionStoreProvider. The default is false.
"ExceptionsEnabled": false, //(Optional)Specifies whether exceptions from cache API are propagated to the page output. Setting this flag is especially helpful during development phase of application since exceptions provide more information about the specific causes of failure. The default is false.
"OperationRetry": 0, //It specifies the number of times server will retry the operation, in case connection is lost with a server while an operation is executing. Its default is zero.
"operationRetryInterval": 0 //It specifies the time interval between each operation retry, in case connection is lost with the server. Its default value is zero.
}
}Ainsi, vous ne pouvez lire que la session. L'accès en écriture n'est accordé qu'à la demande actuelle qui contient le journal, puis nous avons des journaux détaillés disponibles. Des sessions mono-site et multi-sites sont disponibles. Ainsi, toutes ces fonctionnalités ne sont disponibles que si vous branchez notre ASP.NET Core fournisseur de sessions. Les sessions IDistributeCache sont prises en charge mais celles-ci sont limitées. Donc, je vais exécuter cela très rapidement et cela simulerait une application qui finirait par se connecter à cet ASP.NET Core cache
En fait, laissez-moi arrêter ça. Permettez-moi d'abord d'ajouter ma boîte en tant que client. Donc, ici, tout ce que j'ai à faire est d'ajouter la boîte client qui est ma boîte ici.
Voilà. J'ai maintenant toutes les configurations et maintenant je peux exécuter cette application une fois de plus et cela devrait être autorisé à se connecter à mon cluster de cache. Très bien. Donc, cela prendra un certain temps pour la première instanciation.
Donc, cela créerait un objet de session à l'intérieur NCache. Je verrai, si je passe à l'aspect monitoring je verrais un client connecté. Une fois le fournisseur initialisé, ce client établirait une connexion avec 107 et 108 et créerait des objets de session à l'intérieur NCache. Pour le moment, un seul objet de session serait créé car il s'agit de l'utilisateur principal. Je vais être le seul utilisateur connecté, mais si vous avez plusieurs utilisateurs d'application, vous verrez plusieurs sessions créées à l'intérieur NCache. Mais, l'idée ici est, c'est très simple que tout ce que vous avez à faire est d'ajouter ces deux lignes de codes. Ajouter NCache session, puis dites Utiliser NCache session.
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
//To test sessions with NCache Distributed Cache, uncomment the following lines and comment the line after it
//services.AddNCacheDistributedCache(Configuration.GetSection("NCacheSettings"));
//services.AddSession();
services.AddNCacheSession(Configuration.GetSection("NCacheSettings"));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
//To test NCache Distributed Cache, uncomment this and comment the line below this
//app.UseSession();
app.UseNCacheSession();
... Ces méthodes d'extension vont tout couvrir. La première instanciation prend un peu plus de temps, c'est ce que nous avons vu dans ASP.NET Core mais une fois que c'est le cas, les applications sont opérationnelles, nous devrions pouvoir le tester très rapidement. Voilà. Un client est déjà connecté, donc, je pense que nous y sommes.
En attendant, permettez-moi d'exécuter une commande rapide indiquant l'exportation. Cet outil vide toutes les clés de cache qui s'y trouvent actuellement.
Donc, je m'attends à ce qu'un objet de session soit ajouté dans le cache car un client est connecté et cela devrait me permettre d'avoir deux sessions. Un de la tentative précédente et un de celui-ci sont déjà là. Voilà.
Il s'agit d'un jeu de devinettes qui vous permet de deviner un nombre et il ajoute ces nombres à l'intérieur de la session et il affiche également ces nombres. Alors, laissez-moi juste deviner un plus grand nombre et c'est ainsi qu'il va faire une demande à NCache.
Donc, c'est une application assez simple mais si vous revenez ici, nous avons deux éléments dans le cache qui s'y trouvent et vous avez dû voir ces deux requêtes que je viens de faire NCache du côté serveur.
Donc, cela complète notre première démonstration, que vous pouvez brancher NCache pour la mise en cache de session. Il y a beaucoup de fonctionnalités. Les sessions mono-site et multi-sites sont prises en charge. Le verrouillage de session est pris en charge. Une journalisation étendue est disponible. C'est très sécurisé. Nous avons la sécurité et le cryptage en plus. Donc, c'est un package complet, si vous prévoyez d'utiliser NCache pour la mise en cache de session.
ASP.NET Core Mise en cache des réponses
La deuxième fonctionnalité ici est ASP.NET Core mise en cache des réponses. En cela, nous avons des en-têtes http sur les applications. Vous pouvez choisir de mettre en cache les sorties de page et d'utiliser NCache middleware de mise en cache des réponses pour la mise en cache et c'est à nouveau via l'interface IDistributedCache. Donc, si je reviens ici, nous avons ceci exemple d'application.
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Alachisoft.NCache.Caching.Distributed;
namespace ResponseCaching
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
services.Configure<CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
#region Option1
// Reading NCacheSettings using appsettings.jsonDonc, tout ce que vous avez à faire pour l'utiliser est d'utiliser ce package NuGet NCache.Microsoft.Extensions.Caching. Cela couvrira les sessions, IDistributedCache pour la mise en cache des objets et la mise en cache des réponses dans un package NuGet.
Et la prochaine chose que vous devez faire est services.AjouterNCacheCache distribué.
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
services.Configure<CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
#region Option1
// Reading NCacheSettings using appsettings.json
services.AddNCacheDistributedCache(Configuration.GetSection("NCacheSettings"));
#endregion
#region Option2
// Reading NCacheSettings using hardcoded values
//services.AddNCacheDistributedCache(options =>
//{
// options.CacheName = "myPartitionedCache";
// options.EnableLogs = true;
// options.ExceptionsEnabled = true;
//});
#endregion
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}Donc, c'est une interface IDistributedCache qui est branchée mais nous l'utiliserons pour la mise en cache des réponses et dans les paramètres de l'application, nous avons les noms de cache et certains paramètres de journalisation que nous avons configurés et si je reviens ici, vous auriez la mise en cache des réponses également configuré, services.AddResponseCaching();
...
namespace ResponseCaching
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
services.Configure<CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
...Donc, cette application s'attend à ce que la mise en cache des réponses soit effectuée. Cela se ferait à travers NCache à l'aide de l'interface IDistributedCache. Donc, je vais exécuter cela très rapidement car cela prend un certain temps, puis je m'attends à ce qu'il puisse réellement se connecter à NCache puis nous vous montrerons les données ajoutées.
Si je vous montre le code. Vous savez, vous pouvez également spécifier des configurations en ligne. Par exemple, "AjouterNCacheDistributedCache' et vous pouvez dire le nom du cache 'demoClusteredCache' ou 'aspCoreCache' et vous pouvez spécifier tous les paramètres en ligne
public void ConfigureServices(IServiceCollection services)
{
...
services.AddNCacheDistributedCache(configuration =>
{
configuration.CacheName = "demoClusteredCache";
configuration.EnableLogs = true;
configuration.ExceptionsEnabled = true;
});
...
}
ou vous pouvez simplement utiliser le NCache réglage et donner des paramètres à travers NCache paramètres, ici. Cela peut être via la configuration ou via les paramètres en ligne. Donc, c'est très simple de ce côté-là.
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
//remaining services here
...
//Add NCache services to the container
services.SetNCacheSessionConfiguration (
Configuration.GetSection("NCacheSettings"));
services.AddNCacheDistributedCache();
services.AddMvc();
}
Si je reviens ici maintenant, nous nous attendons à ce que deux clients soient connectés car l'application de mise en cache des réponses établirait également une connexion avec NCache et nous verrions certains éléments dans le cache à la suite de cela.
Question: Comment exactement les données sont-elles cryptées et sécurisées ?
Permettez-moi de montrer cet exemple de mise en cache de réponse, puis je vous montrerai les fonctionnalités de cryptage de sécurité à l'intérieur NCache. Donc, nous avons l'application en cours d'exécution et, comme vous pouvez le voir, nous avons ajouté quelques éléments. Si j'actualise simplement ceci, nous avons les valeurs mises à jour à partir d'ici et c'est le cas, le contenu de sortie de cette page est stocké à l'intérieur NCache grâce à notre mise en cache des réponses et si je vous montre les clés de cache, nous avons maintenant quelques éléments supplémentaires dans le cache. Donc, deux éléments en plus des éléments de session qui sont déjà là.
Maintenant, revenons à cryptage de sécurité. Ceux-ci sont très étendus à l'intérieur NCache. Nous avons des fonctionnalités de sécurité et de cryptage. Il existe de nombreux fournisseurs de sécurité parmi lesquels vous pouvez choisir. Nous avons des fournisseurs AES et DES. Plusieurs de ceux-ci. Nous avons des fournisseurs de chiffrement conformes à la norme FIPS et nous prenons également en charge TLS 1.2. Ainsi, la sécurité au niveau du transport est également disponible avec NCache. Donc, c'est ce qui couvre votre cryptage. Où vous pouvez avoir un cryptage de bout en bout entre vos boîtes client et serveur, puis du point de vue de la sécurité, vous pouvez choisir qui pourrait être des administrateurs de cache, qui pourrait être des utilisateurs de cache et nous avons un fournisseur de sécurité de cryptage LDAP basé sur Active Directory que vous peut se brancher.
Donc, s'il y a des questions spécifiques, vous pouvez nous envoyer un e-mail et nous travaillerons avec vous et partagerons tous ces détails sur la façon de les configurer. Mais nous avons un soutien très étendu à l'intérieur NCache. Alors, reviens ici. Donc, cela couvre notre ASP.NET Core Mise en cache des réponses.
ASP.NET Core SignalR Backplane
La fonctionnalité suivante est ASP.NET Core SignalR Backplane. Dans ce cas, si vous utilisez une ferme Web, vous pouvez utiliser NCache comme fond de panier pour celui-ci et par rapport aux fonds de panier conventionnels, NCache est beaucoup plus rapide, très fiable et très évolutif également.
Voici donc le package NuGet que j'ai ajouté. AspNetCore.SignalR.NCache que vous pouvez rechercher. Il est déjà installé. Tout ce que vous avez à faire, encore une fois, il prend un nom de cache via les paramètres de l'application, puis voici la méthode d'extension. Donc, si vous avez services.AddSignalR, nous avons une méthode d'extension où il ajoute NCache possède de SignalR Backplane pour ASP.NET Core applications.
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
services.Configure<NCacheConfiguration>(Configuration.GetSection("NCacheConfiguration"));
services.AddSignalR().AddNCache(ncacheOptions =>
{
ncacheOptions.CacheName = Configuration["NCacheConfiguration:CacheName"];
ncacheOptions.ApplicationID = Configuration["NCacheConfiguration:ApplicationID"];
// Uncomment in case of cache security enabled.
//ncacheOptions.UserID = Configuration["NCacheConfiguration:UserID"];
//ncacheOptions.Password = Configuration["NCacheConfiguration:Password"];
});
}Je vais le faire très vite parce que ça prend du temps. Je pense que beaucoup de choses tournent. Donc, je vais exécuter cet échantillon. Donc, cela lancerait une application de chat et elle utiliserait, dans les coulisses, elle utilise la messagerie Pub/Sub de NCache. Donc, pour cela, ce que je vais vraiment faire, je reviendrai ici et côté serveur, je vous montrerai des compteurs de performances, ce qui vous permettra de gérer et de surveiller spécifiquement les messages Pub/Sub et SignalR utilise Pub/ Messagerie secondaire dans les coulisses. Alors, permettez-moi de dire SignalR, à droite. Donc, et si vous remarquez ici, nous avons une section de messagerie ici. Où nous pouvons voir la taille du magasin de messages, le nombre de messages, livrés par seconde, expirés par seconde, publiés, le nombre de sujets.
Les sujets vous permettent d'avoir une séparation des préoccupations. Applications multiples utilisant NCache en tant que SignalR Backplane ils auraient plusieurs sujets créés à l'intérieur NCache. Ainsi, les sujets d'un message de nature similaire peuvent être attribués à un sujet distinct. Par exemple, vous pouvez créer un sujet pour les commandes. Vous pouvez créer un sujet pour les messages clients. Ainsi, vous pouvez avoir différents messages dans différents sujets et les abonnés connectés à un sujet distinct ne reçoivent que les messages qui leur sont liés. Donc, voyez déjà une activité ici, ce qui signifie que mon application est opérationnelle. Donc, si je reviens au tableau de bord du serveur, nous avons maintenant trois applications en cours d'exécution. Je ne verrai rien dans les statistiques régulières. Je verrais tout dans les statistiques de messagerie. Ainsi, vous pouvez voir le nombre de messages.
Donc, il y avait des messages, la taille du magasin, c'est environ 800 octets. Message publié et ensuite nous avons je pense que d'autres paramètres sur la date ne sont pas là car nous n'avons pas encore d'expiration.
Donc, pour en revenir à mon application, j'exécuterais une autre instance de ceci. D'accord, j'ai donc deux candidatures. J'aurais dû l'exécuter en mode incognito, mais testez le message dès que vous l'envoyez, il est également envoyé ici. Testez le message 2 et vous verriez également ce message de l'autre côté, à droite, et si je reviens ici, nous avons une activité en cours ici.
Ainsi, il utilise la messagerie Pub/Sub dans les coulisses et vous permet de créer un fond de panier. Donc, SignalR lui-même, le cas d'utilisation pour cela, qu'il met l'accent sur la notification push au lieu de l'interrogation des utilisateurs que vous pouvez envoyer du contenu à vos utilisateurs. Mais avec la batterie de serveurs Web, il existe une limitation selon laquelle vous ne pouvez transmettre le contenu qu'aux clients connectés à ce serveur Web. Si vous avez plusieurs serveurs Web, vous avez besoin d'un corps central et d'un fond de panier par ASP.NET et ASP.NET Core résout cela.
Vous pouvez donc utiliser NCache comme fond de panier pour cela. C'est une plate-forme de communication où tous les messages sont relayés vers NCache, Envoyé à NCache et alors NCache envoie à son tour à tous les serveurs Web, le diffuse et ces serveurs Web sont capables de transmettre ces messages à leurs utilisateurs finaux, éventuellement. Donc, c'est ce qui rend très rapide l'architecture globale très rapide parce que le NCache est en mémoire. C'est super rapide, très évolutif, très fiable, hautement disponible.
D'accord. Donc, je pense que nous sommes bons sur ce front. Des questions? Sinon, je vais passer à autre chose et parler de l'aspect de la mise en cache des données. Nous allons donc passer les 10 à 15 dernières minutes sur la mise en cache des données, certaines des fonctionnalités. Il y a beaucoup de fonctionnalités sur ce front. Donc, je voudrais rapidement en présenter quelques-uns.
Donc, tout d'abord, il existe de nombreuses façons d'utiliser NCache pour la mise en cache de la base de données ou la mise en cache des données de l'application. Où vous cachez les données à l'intérieur NCache & vous économisez des trajets vers la base de données principale. Si vous utilisez déjà IDistributedCache, bien que ce soit très limité, vous pouvez brancher NCache en tant que fournisseur.
J'ai un exemple d'application ici. Encore une fois, c'est très simple. Vous devez ajouter le package NuGet. C'est ASP.NET Core ainsi que NCache.Microsoft.Extensions.Caching.
public async Task<IActionResult> onPostResetCachedTime()
{
var currentTimeUTC = DateTime.UtcNow.ToString();
byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
var options = new DistributedCacheEntryOptions()
.SetAbsoluteExpiration(TimeSpan.FromSeconds(20));
_cache.Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
return RedirectToPage();
}Donc, cela couvre IDistributedCache et ensuite vous avez besoin des paramètres de l'application où vous spécifiez le nom du cache et à l'intérieur de startup.cs que vous branchez. services.AddNCacheDistributedCache donne les paramètres via la configuration ou vous pouvez utiliser l'option deux où vous spécifiez les configurations, tous les paramètres via le code directement.
public void ConfigureServices(IServiceCollection services)
{
// Reading NCacheSettings using appsettings.json
services.AddNCacheDistributedCache(_config.GetSection("NCacheSettings"));
services.AddMvc().SetCompatibilityVersion(Microsoft.AspNetCore.Mvc.CompatibilityVersion.Version_2_2);
}Et, dans le index.html.cs, nous avons quelques méthodes ici. Où nous appelons cache.GetAsync.
public string CachedTimeUTC { get; set; }
public async Task OnGetAsync()
{
CachedTimeUTC = "Cached Time Expired";
var encodedCachedTimeUTC = await _cache.GetAsync("cachedTimeUTC");
if(encodedCachedTimeUTC != null)
{
CachedTimeUTC = Encoding.UTF8.GetString(encodedCachedTimeUTC);
}
}Et une chose que vous devez noter est cette interface IDistributedCache, par exemple, si je vous montre le GetAsync, il reprend un tableau d'octets. Donc, ce n'est pas un objet sérialisé ou désérialisé que vous obtenez. Vous devez faire la sérialisation et la désérialisation vous-même.
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.Extensions.Caching.Distributed
{
public interface IDistributedCache
{
byte[] Get(string key);
Task<byte[]> GetAsync(string key, CancellationToken token = default);
void Refresh(string key);
Task RefreshAsync(string key, CancellationToken token = default);
void Remove(string key);
Task RemoveAsync(string key, CancellationToken token = default);
void Set(string key, byte[] value, DistributedCacheEntryOptions options);
Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options,
CancellationToken token = default);
}
}Ce que nous avons fait dans cet exemple, nous l'avons en fait pris de telle manière que nous sérialisons l'objet avant de l'ajouter et après l'avoir récupéré, nous le désérialisons, d'accord. Donc, nous récupérons la chaîne à travers cela.
public string CachedTimeUTC { get; set; }
public async Task OnGetAsync()
{
CachedTimeUTC = "Cached Time Expired";
var encodedCachedTimeUTC = await _cache.GetAsync("cachedTimeUTC");
if(encodedCachedTimeUTC != null)
{
CachedTimeUTC = Encoding.UTF8.GetString(encodedCachedTimeUTC);
}
}Donc, c'est quelque chose que nous avons fait intensivement et c'est ce que vous devez faire. Avec NCache directement utilisé comme plate-forme de mise en cache des données de votre application, vous n'avez pas à faire tout cela. NCache sérialisera et désérialisera vos objets automatiquement. Il vous suffit de les marquer comme sérialisables.
Donc, je vais exécuter cet exemple très rapidement et cela devrait également me permettre de présenter l'interface IDistributedCache et enfin pendant son exécution, je voudrais également construire, donc, c'est notre interface IDistributedCache et c'est la deuxième option ici, que je montre ici, est le direct NCache Apis. Voici nos API.
/*Cache Connection*/
Cache cache = NCache.InitializeCache("myCache");
cache.Dispose();
/*Fetching Data*/
Employee employee = cache.Get<Employee>("Employee:1000");
bool isPresent = cache.Contains("Employee:1000");
/*Writing Data*/
cache.Add("Employee:1000", employee);
cache.AddAsync("Employee:1000", employee);
cache.Insert("Employee:1000", employee);
cache.InsertAsync("Employee:1000", employee);
Employee employee = (Employee) cache.Remove("Employee:1000");
cache.RemoveAsync("Employee:1000");Alternativement, que nous vous recommandons fortement d'obtenir plus de contrôle si vous gérez tout par le biais direct NCache Appels API. Vous vous connectez à NCache en utilisant initialize cache ou get cache dans les versions actuelles, puis vous dites cache.Get pour récupérer le cache des éléments.Add pour ajouter des éléments. Ajouter asynchrone est également disponible Insérer et Insérer asynchrone est également disponible et vous pouvez ensuite appeler cache.Remove. C'est donc la deuxième approche que je montrerai une fois que cet exemple sera exécuté et que IDistributedCache sera pris en charge, mais nos API directes sont plus riches en fonctionnalités en comparaison.
Question: Pouvons-nous utiliser NCache API avec IDistributedCache et pour cela, où pouvons-nous obtenir les échantillons ?
Donc, tout d'abord oui, vous pouvez utiliser IDistributedCache. Vous devez déjà utiliser IDistributedCache. Ainsi, vous pouvez brancher NCache comme source pour cela. Donc, cela pourrait être un point de départ et en plus de cela, vous pouvez également commencer à utiliser nos API directes dans la même application. Donc, oui, vous pouvez le faire. Nous ne vous limitons pas à utiliser l'un ou l'autre. Tous ces cas d'utilisation dont nous avons discuté de la mise en cache de session, de la mise en cache de réponse, SignalR Backplane, IDistributedCache ou direct NCache Appels API. Cinq de ces fonctionnalités, vous pouvez également toutes les utiliser dans une seule application. Alors, c'est la beauté de NCache où vous pouvez combiner tous ces cas d'utilisation.
Exemples d'applications, tous ces exemples sont, ils sont installés avec NCache, à droite. Donc, nous n'utilisons rien de personnalisé ici. Ainsi, tous ces éléments sont disponibles dans l'exemple de fichier de programme, NCache échantillons. Ceux-ci sont également publiés sur notre site Web.
Donc, cet échantillon a été exécuté. Donc, si je réinitialisais le temps de cache, cela le ferait et si je revenais rapidement ici, je présenterais les clés de cache et maintenant vous verriez d'autres clés de cache. Je pense que certains éléments ont expiré, mais vous voyez l'heure UTC du cache. Certains objets de mise en cache de réponse doivent avoir expiré.
C'est ainsi que vous utilisez l'interface IDistributedCache avec NCache.
Maintenant, je vais présenter le direct NCache Appels API, que nous recommandons vivement. C'est quelque chose que vous pouvez aussi faire. Donc, pour cela, vous pouvez utiliser le Alachisoft.NCache.SDK Paquet NuGet. C'est notre SDK complet, qui apporte toutes les ressources côté client et toutes les fonctionnalités peuvent être exposées côté client en utilisant ce SDK et sur cette base, je peux dire inclure ces espaces de noms Alachisoft.NCache.Client et vous pouvez également inclure Alachisoft.NCache.Durée car il existe des fonctionnalités avancées que vous pouvez utiliser à travers cela.
using Alachisoft.NCache.Runtime;
using Alachisoft.NCache.Sample.Data;
using Alachisoft.NCache.Client;
using System;
using System.Configuration;
using Alachisoft.NCache.Runtime.Caching;
namespace Alachisoft.NCache.Samples
{
public class BasicOperations
{
private static ICache _cache;
}
}
...Interface ICache. C'est notre propre interface contrairement à IDistributedCache, c'est vrai. Donc, nous avons beaucoup de fonctionnalités comme vous pouvez le voir en comparaison et dans celles-ci, nous avons également plusieurs fonctionnalités. Voici donc quelques objets sur ICache.
Ainsi, vous pouvez initialiser le cache. L'initialisation se fait par NCache.Client. CacheManager.GetCache, c'est ainsi que vous vous y connectez. Vous obtenez un handle de cache et en utilisant ce handle de cache, vous pouvez configurer une expiration basée sur le temps. Donner l'objet qui est client dans ce cas, AjouterObjetAuCache et nous obtenons un client. Ensuite, vous dites cache.Add un élément de valeur clé est ajouté. Ainsi, l'objet client serait automatiquement sérialisé pendant que vous l'ajouteriez au cache, puis la récupération se fait via cache.Get, mise à jour via cache.Insert, où vous pouvez modifier certaines valeurs. Modifiez l'heure d'expiration, puis vous pouvez appeler cache.Remove pour supprimer également les données.
Donc, dans cet échantillon si rapidement. Très bien. Donc, il obtient le cache à partir des paramètres de l'application. Si je donne le nom de ce cache au cache principal asp, cela commencera également à utiliser le même cache pour la mise en cache des données et vous avez déjà vu ceci où j'ai utilisé le même cache dans différentes applications mais, s'il s'agit d'une grande application utilisant toutes ces fonctionnalités en conjonction les unes avec les autres, en combinaison les unes avec les autres, sont également prises en charge.
Ainsi, pendant son exécution, il existe de nombreuses fonctionnalités. J'en montre juste un ou deux dans les exemples car ce ne sont que des opérations de base et cela ajouterait des données dans le cache. Il se peut que cela ne s'arrête à aucun moment, je n'en suis pas trop sûr, mais voyons voir. En attendant, si je vous montre qu'un client est connecté. Il a fait quelques opérations, à droite. Espérons-le. Permettez-moi de mettre un point d'arrêt quelque part et de l'exécuter une fois de plus.
Donc, ce qu'il a vraiment fait, c'est qu'il a en fait initialisé le cache, ajouté un objet, l'a récupéré, l'a mis à jour, l'a récupéré à nouveau, puis l'a supprimé, puis le cache a été supprimé. Donc, avant de disposer, j'ai mis un point d'arrêt, donc j'espère que vous pouvez maintenant voir cela initialisé, ajouté, récupéré, les détails mis à jour, mis à jour dans le cache. Ainsi, toutes ces méthodes ont été exécutées.
Donc, c'est aussi simple que cela d'exécuter cet exemple. Tout ce dont vous avez besoin est le package NuGet et les espaces de noms à inclure, puis jouez avec différentes API, que je vais montrer ici.
De nombreuses fonctionnalités sont disponibles. Je vais passer les 5 à 6 dernières minutes sur différentes fonctionnalités, qui sont disponibles dans le cadre de notre direct NCache Apis. Ainsi, vous pouvez utiliser une expiration basée sur le temps. L'expiration absolue et glissante est disponible. Absolute, c'est quand vous donnez un temps à l'avance et que les données seront supprimées une fois ce temps écoulé. Le glissement, c'est que si vous continuez à utiliser ces données, disons que vous avez une expiration glissante de 10 minutes, si vous n'accédez pas à cet élément pendant 10 minutes, alors seulement il est supprimé. Sinon, il resterait dans le cache si vous continuez à utiliser cet objet.
Vous pouvez synchroniser votre cache avec la base de données. Tout changement dans le contenu de l'élément mis en cache, à droite. Par exemple, l'élément mis en cache toute modification dans l'enregistrement de la base de données. Si vous avez des éléments en cache qui appartiennent à la base de données, toute modification dans la base de données invaliderait l'élément du cache et nous avons une dépendance SQL pour cela, qui est basée sur les événements. Nous avons une dépendance basée sur la base de données, la dépendance d'interrogation de la base de données, qui est basée sur l'interrogation. Il regroupe les modifications et s'il trouve que certains enregistrements de la base de données ont été modifiés, il supprimera les éléments correspondants du cache. Procédures stockées .NET CLR, où vous pouvez effectuer directement NCache Appels d'API directement depuis les serveurs de base de données. Vous pouvez également synchroniser votre cache avec des bases de données non relationnelles. Dépendances de fichiers disponibles. Vous pouvez rendre les éléments du cache dépendants des fichiers. Ou il peut également s'agir d'une dépendance personnalisée, où vous exécutez un registre de code avec NCache et cela déterminerait si cet élément doit être expiré du cache. Ainsi, en fonction de votre logique métier, vous pouvez faire expirer des éléments du cache. Nous avons une dépendance de base clé. Vous pouvez l'utiliser pour gérer les relations entre les éléments mis en cache. Ainsi, les relations un à un, un à plusieurs et plusieurs à plusieurs peuvent être gérées à l'intérieur NCache.
Prise en charge côté serveur, la prise en charge du code est très étendue. Vous pouvez utiliser le modèle de mise en cache ou vous pouvez utiliser le modèle de lecture et d'écriture, où vous lisez dans le cache, à partir du cache, et si les données ne sont pas dans le cache, vous pouvez lire dans le cache en exécutant votre fournisseur. C'est une interface que vous implémentez et enregistrez avec nous et vous pouvez lire le cache et obtenir cet élément ou le détruire à partir de la base de données principale.
Et l'écriture immédiate est à l'opposé, où vous mettez à jour le cache, puis vous pouvez également mettre à jour automatiquement la base de données principale en appelant votre gestionnaire d'écriture immédiate, une interface que vous implémentez et enregistrez et écrivez derrière mettrait à jour la base de données principale de manière asynchrone, ce qui est très rapide en comparaison, où vous n'avez pas besoin de même pour les opérations d'écriture, votre élément de cache ne sera mis à jour que dans le cache et votre application revient et dans les coulisses, le cache mettrait à jour les bases de données principales.
Des groupes, des sous-groupes sont disponibles. Vous pouvez créer des collections logiques à l'intérieur NCache. Les balises sont prises en charge. Vous pouvez attacher des mots-clés sur les éléments et vous pouvez récupérer, supprimer ou récupérer ou même jouer ou rechercher des éléments en fonction de leur étiquette correspondante.
Les recherches SQL Like sont disponibles. Les recherches SQL et LINQ sont prises en charge. Vous pouvez rechercher des éléments en fonction de leurs attributs. Vous pouvez exécuter un critère de recherche, qui peut aller quelque chose comme sélectionner des produits où le produit est le type d'objet où et dire sélectionner des produits où le produit.prix est supérieur à 10 et le produit .prix est inférieur à 100. Ainsi, en fonction de vos critères spécifiés NCache formulerait le jeu de résultats dans vos applications.
Et les requêtes LINQ sont également prises en charge. Ceux-ci sont parallèles. L'indexation des données est prise en charge dans ce cadre. Vous en avez besoin comme un must qui rend la recherche très rapide de NCache.
Messagerie Pub/Sub et événements
La messagerie et les événements Pub/Sub constituent une fonctionnalité distincte. Nous avons une plate-forme de messagerie Pub/Sub pilotée par des événements asynchrones. Nous avons une requête continue basée sur des critères, où vous pouvez mapper un ensemble de données et obtenir des événements à partir de cet ensemble de données. Par exemple, vous pouvez mapper tous les produits, où les prix des produits sont inférieurs à 100. Cela pourrait donc être votre ensemble de données. Tout changement dans cet ensemble de données vous serait notifié.
Des événements de base clés sont disponibles. Ainsi, vous pouvez être averti si un élément est mis à jour ou supprimé ou s'il peut s'agir d'un niveau de cache où tous les éléments sont surveillés.
Cluster de cache dynamique
Enfin quelques détails sur NCache regroupement. Il est basé sur le protocole de clustering de cache dynamique. NCache vous permet d'ajouter ou de supprimer des serveurs à la volée. Il n'y a donc pas de point de défaillance unique. En cas de panne d'un serveur, il est géré dans le cadre du protocole. Si vous ajoutez plus de serveurs, il démarre automatiquement en utilisant le serveur nouvellement ajouté. Si un serveur tombe en panne, vous n'avez pas de temps d'arrêt même dans ce cas et il n'y a pas de point de défaillance unique, principalement parce qu'il existe plusieurs serveurs hébergeant ce cache.
L'ajout et la suppression de serveurs sont transparents, en ce qui concerne vos applications. Vous donne un temps de disponibilité de 100 %, un scénario de cache hautement disponible, puis nous avons déjà couvert les topologies.
Nous avons des Cache Client. Réplication WAN fonctionnalités. Vous pouvez avoir une réplication de site à site entre des sites actifs-actifs ou actifs-passifs. C'est aussi géré.
Donc, vous savez que la liste est longue. Je pense que nous avons couvert beaucoup de détails et je voulais vous donner un aperçu rapide de la façon dont vous pouvez réellement utiliser NCache en ASP.NET Core. Donc, nous nous dirigeons déjà vers la fin de cette présentation. Je pense qu'un marqueur d'heure.
Je pense, concluons ceci à ce stade. S'il vous plaît laissez-moi savoir s'il y a des questions jusqu'à présent ? Sinon, je vais le confier à Zack et ensuite il pourra s'en charger à partir de là. Des questions? Nous allons laisser la parole ouverte pendant environ une minute. Si vous avez des questions ou si vous en réfléchissez encore, n'hésitez pas à les poser.
Et pendant que nous y sommes, nous avons à peu près couvert toutes ces fonctionnalités que vous voyez. ASPIC.NET Core Sessions, mise en cache des réponses, SignalR Backplane, IDistributedCache, mise en cache des données et direct NCache Appels d'API et nous avons même des exemples d'applications pour la messagerie Pub/Sub. Si vous êtes intéressé séparément par cette section, vous pouvez également obtenir un exemple d'application distinct.
Question: Cette présentation sera-t-elle disponible plus tard ?
Oui ce sera. Nous pourrons non seulement obtenir un enregistrement du webinaire, mais nous aurons également les diapositives disponibles si vous souhaitez les télécharger et les utiliser également et vous recevrez un e-mail vous renvoyant au webinaire enregistré une fois qu'il sera prêt. Ainsi, vous pouvez toujours accéder à notre site Web une fois qu'il est en direct et sous les webinaires enregistrés, vous pouvez les trouver.
Question: Quelle est la différence entre IDistributedCache et NCache ASP.NET Core Fournisseur de magasin de sessions ?
D'accord, donc, je crois que la question est plus axée sur la différence d'utilisation de session via IDistributedCache et Session l'utilise via notre fournisseur de cache. Ainsi, à un niveau élevé, IDistributedCache est limité en termes de fonctionnalités. NCache fournisseur vous donne plus de contrôle. Tout d'abord, vous pouvez utiliser le verrouillage de session. IDistributedCache Session est un magasin basé sur le non-verrouillage. Vous pouvez utiliser des sessions mono-site et multi-sites. C'est une caractéristique spécifique à l'intérieur NCache qui n'est pas disponible dans IDistributedCache. Bien que, NCache prend en charge le fournisseur de session IDistributedCache tel quel. Cela vous offre de nombreux avantages en plus de IDistributedCache, mais lorsque nous comparons les sessions IDistributedCache avec NCache et vous savez, NCache Fournisseur de magasin de sessions avec NCache, c'est là que NCache fournisseur a un net avantage. Ensuite, il y a beaucoup de fonctionnalités telles que le partage de session entre différentes applications. Il existe un attribut ID d'application de session que vous pouvez spécifier. Vos exceptions peuvent être enregistrées dans le journal des événements, des journaux de cache peuvent être créés, des journaux client peuvent être créés. Donc, il y a une énorme liste de fonctionnalités qui sont différentes entre ces deux.
Donc, il est fortement recommandé que si vous utilisez la mise en cache de session avec NCache, donc je recommanderais personnellement de revoir notre fournisseur de magasin de session par rapport à IDistributedCache Session avec NCache parce que vous obtenez beaucoup d'avantages.
Question: Comment le regroupement des données peut-il faciliter la récupération des données ?
À droite. Ainsi, vous attachez un groupe à plusieurs éléments, puis il existe des API basées sur des groupes où vous dites obtenir des données de groupe et vous obtenez tous ces éléments à la fois. Ainsi, vous n'avez pas à donner les clés de ces objets individuels séparément. Ainsi, il le fait avec un seul appel API, toutes les données du groupe peuvent être récupérées. Vous pouvez supprimer des données en un seul appel d'API. C'est ainsi que le processus de récupération et de mise à jour est plus facile en comparaison.