En utilisant NCache dans AWS Elastic Kubernetes Service (EKS)
Cluster Elastic Kubernetes avec conteneurs Docker
AWS Elastic Kubernetes Service (EKS) est un service Kubernetes géré par Amazon Web Services (AWS) qui vous permet de configurer votre cluster Kubernetes avec tous les derniers correctifs et mises à niveau de l'infrastructure sous-jacente qui le prend en charge.
Si vous travaillez avec .NET/.NET Core ou des applications Java s'exécutant dans EKS et que vous souhaitez utiliser NCache pour améliorer leurs performances et leur évolutivité pendant les pics de charge des transactions, alors soyez assuré que NCache prend pleinement en charge cet environnement.
Regardez cette vidéo pour voir à quel point il est facile de déployer NCache dans votre cluster Amazon Elastic Kubernetes.
NCache Déploiement dans EKS
Dans le cloud AWS, nous avons un équilibreur de charge classique devant un contrôleur d'entrée, qui s'exécute dans le cluster Kubernetes. La ressource Kubernetes Ingress implémentée par ce contrôleur d'entrée achemine les requêtes HTTP provenant de l'équilibreur de charge vers les différents services exécutés au sein du cluster. Désormais, dans de tels environnements d'applications distribuées, nous devons également disposer d'une solution de mise en cache distribuée, qui offre évolutivité, fiabilité et haute disponibilité, lors de l'exécution d'opérations de lecture rapide et c'est là que NCache entre en jeu.
NCache peut être déployé dans votre cluster EKS en tant que NCache serveurs qui s'exécutent dans des conteneurs Linux et ces conteneurs sont hébergés dans les pods Kubernetes. Les adresses IP de ces NCache les serveurs sont résolus par le Service de découverte de cache, qui est un service sans tête Kubernetes et dont les adresses IP sont utilisées par les applications clientes pour créer des descripteurs de cache avec lesquels elles peuvent se connecter au NCache cluster et commencer à effectuer des opérations de gestion et CRUD.
Voici les paramètres importants de la démonstration que nous allons effectuer aujourd'hui. Le NCache Les serveurs qui seront déployés sur le cluster EKS utiliseront l'image Docker suivante 'alachisoft/ncache' avec une étiquette de 'entreprise-serveur-linux-5.0.2'.
Pour obtenir toutes les images qui NCache fournit, permettez-moi d'en venir au Alachisoft site Internet. Sélectionnez le 'Télécharger' onglet puis cliquez sur 'NCache'. Cela vous amènera au NCache centre de téléchargement. En faisant défiler jusqu'à la section "Docker Hub", je peux simplement cliquer sur la deuxième entrée à partir du haut et cela me dirigera vers le Docker Hub page Alachisoft NCache. Ici vous pouvez voir toutes les images qui NCache fournit. Pour en revenir aux paramètres, l'image qui sera utilisée a pour NCache Enterprise Édition 5.0 SP2 avec un .NET Core installation. Le cache en cluster que nous allons créer utilisera la partition de la topologie de réplique. Les deux applications de test qui seront utilisées sont les suivantes. Nous en avons un .NET Core Application et une application Java et, dans les deux cas, nous montrerons l'aspect App Data Caching de NCache. Nous allons commencer par 2 NCache serveurs, puis augmentez ce nombre à 3. Pour le démontrer, nous pouvons apporter des modifications dynamiques au NCache l'état du cluster sans affecter les performances du client.
Créer un cluster EKS
Nous sommes maintenant prêts à commencer notre démonstration. La première chose à faire est bien sûr de mettre en place l'infrastructure EKS sur laquelle nous allons déployer notre NCache ressources serveur et client. Ici, je suis sur la page de démarrage d'AWS pour le service EKS. Vous trouverez ici toutes les informations nécessaires pour que votre premier cluster EKS soit opérationnel. Les informations incluent les prérequis tels que le rôle IAM et les stratégies requises.
De plus, il entre dans les détails de la création d'un VPC, sur lequel vous déploierez votre cluster EKS.
Plus bas, vous trouverez des informations sur l'installation et l'utilisation de l'AWS CLI et des utilitaires de ligne de commande « kubectlc » pour l'accès et la gestion du cluster Kubernetes.
Sont également incluses des informations sur le groupe de nœuds gérés par Kubernetes, qui fournira les nœuds de travail, sur lesquels vous déploierez vos ressources Kubernetes. J'utiliserai les informations données ici pour créer un cluster EKS sur un VPC avec 2 sous-réseaux publics et 2 privés et une fois que mon cluster EKS sera opérationnel, je poursuivrai le reste de la démonstration.
En utilisant ces étapes indiquées dans la page de démarrage, j'ai déjà créé les rôles IAM et l'infrastructure VPC pour mon cluster EKS. Maintenant, je vais passer par ces étapes de création de l'infrastructure EKS.
Alors, pour cela, je suis sur ma console de gestion AWS et je vais cliquer sur le lien Elastic Kubernetes Service. Cela m'amènera à la page principale du service EKS. Sous l'en-tête « Amazon EKS » dans le volet gauche de la page, je vais cliquer sur le lien « Clusters ».
À l'heure actuelle, je n'ai aucun cluster EKS. Pour cela, je vais cliquer sur le lien "créer un cluster".
Ici, je vais donner dans les paramètres de configuration. Donc, je vais commencer par le nom du cluster EKS qui est 'eks-ncache'. Je vais sélectionner '1.14' pour 'Version Kubernetes'. Je vais également sélectionner le 'rôle IAM' et le 'VPC'. Je vais sélectionner le groupe de sécurité et tout le reste sera conservé par défaut et je vais donner une balise pour le cluster EKS et une fois que tout cela est fait, je vais cliquer sur le bouton "créer".
Maintenant que la Pôle EKS est en cours de création, je vais mettre la vidéo en pause, car cela va prendre un certain temps. Sur la page de mon cluster EKS, je peux voir que 'eks-ncache' c'est actif'. La deuxième étape consiste à créer le groupe de nœuds de gestion et pour cela, je vais faire défiler jusqu'à la section « Groupes de nœuds » et je vais cliquer sur le bouton « Ajouter un groupe de nœuds ».
Je vais donner les paramètres en commençant par le nom du groupe de nœuds et je vais sélectionner le 'rôle IAM'.
Je vais sélectionner la 'paire de clés SSH', cliquer sur 'Suivant'.
Ici, je vais utiliser le 'type AMI' suivant et pour le 'type d'instance', j'utiliserai 't3.small'. Après cela, je vais cliquer sur "Suivant".
Je vais sélectionner 2 nœuds de travail, cliquez sur "Suivant".
Et ici après avoir regardé les paramètres, je vais cliquer sur 'Créer' pour lancer la création de mon groupe de nœuds. Nous voyons ici que le groupe de nœuds est actuellement en cours de création, je vais donc mettre la vidéo en pause. Nous voyons ici maintenant que mon groupe de nœuds EKS est "actif" et que la création de mon infrastructure EKS est terminée.
Dans le terminal PowerShell de ma machine cliente, je vais utiliser l'AWS CLI, pour créer mon fichier 'kubeconfig', pour accéder au cluster EKS et le fichier 'kubeconfig' a été créé. Maintenant, je vais confirmer ma connexion au cluster EKS et nous voyons les deux nœuds de travail qui sont inclus dans le groupe de nœuds gérés par EKS.
Déployer le contrôleur d'entrée
La première chose que je vais faire est de déployer les ressources Kubernetes requises pour le contrôleur d'entrée. Pour en venir au diagramme d'architecture, le contrôleur d'entrée présenté ici sera utilisé pour implémenter la ressource d'entrée que nous déploierons plus tard.
Dans notre démonstration, nous utilisons le contrôleur NGINX Ingress en raison de sa popularité. Tout d'abord, nous allons déployer les ressources obligatoires nécessaires pour faire fonctionner le contrôleur d'entrée NGINX dans n'importe quel environnement Kubernetes, puis nous allons déployer les ressources spécifiques à AWS, qui feront tourner un équilibreur de charge classique devant le NGINX Ingress. Controller et autorisez le NGINX Ingress Controller à recevoir des requêtes HTTP provenant de l'extérieur du cluster Kubernetes via cet équilibreur de charge classique.
Je vais maintenant déployer les ressources obligatoires requises pour le contrôleur d'entrée NGINX. Les définitions de ces ressources peuvent être trouvées en suivant l'URL qui est donnée dans la section en surbrillance. Alors, sans plus tarder, commençons et les ressources obligatoires ont été déployées. Ici, j'ai le fichier YAML ouvert, que je vais utiliser pour déployer deux ressources liées au contrôleur NGINX Ingress.
La première ressource est le service d'équilibrage de charge qui sera utilisé pour faire tourner un équilibreur de charge classique devant le contrôleur d'entrée NGINX. Comme nous pouvons le voir dans la section d'annotation, l'équilibreur de charge fonctionnera à la couche 7 acheminant les requêtes HTTP vers le contrôleur d'entrée NGINX. L'autre ressource que nous allons déployer est la ressource "ConfigMap", qui contient les paramètres de configuration du comportement du contrôleur d'entrée NGINX dans le cluster Kubernetes.
Je vais maintenant déployer ces ressources en utilisant le 'kubectl appliquer' commandement et les moyens ont été déployés. Permettez-moi d'accéder à mon tableau de bord EC2 et de confirmer que l'équilibreur de charge a été lancé. Si j'actualise cette page, vous verrez un nouvel équilibreur de charge introduit. Permettez-moi de cliquer sur le lien "équilibreurs de charge" et voici l'équilibreur de charge devant le contrôleur d'entrée NGINX.
Déployer NCache Serveurs
Nous allons maintenant déployer NCache Serveurs au cluster EKS. Revenant au schéma d'architecture, ces NCache Les serveurs sont utilisés pour créer le cache en cluster dans le cluster EKS. Voici le fichier YAML pour déployer le NCache serveurs au cluster Kubernetes. Comme nous pouvons le voir, il s'agit d'une ressource de déploiement qui tournera jusqu'à NCache serveurs au sein du cluster EKS. Voici les ports sur lesquels le NCache les serveurs seront à l'écoute. Nous avons le port 'management-tcp' avec une valeur de 8250, sur lequel le NCache les serveurs écouteront les demandes de connexion des clients. Nous avons le port 'management-http' avec une valeur de 8251 sur lequel le NCache gestionnaire de sites Web sera à l'écoute et ensuite nous avons le 'client-port' avec une valeur de 9800, sur lequel le NCache les serveurs seront à l'écoute des demandes d'opération CRUD du client.
Le 'kubectl appliquer' commande, je vais maintenant créer la NCache pods de serveur sur mon cluster EKS et vérifions maintenant l'état des pods. Les pods sont en cours d'exécution. Nous avons 2 NCache Serveurs avec les adresses IP indiquées ici.
NCache Service Découverte
Nous allons maintenant déployer le NCache Service Découverte. Le service de découverte de cache est un service sans tête qui s'exécute au-dessus du NCache pods de serveur. Sa fonction est de résoudre les adresses IP qui seront utilisées par les applications clientes, lorsqu'elles voudront se connecter au Cache clusterisé.
Voici le fichier YAML pour le service sans tête Kubernetes. Comme nous pouvons le voir, le nom du service sera "cacheserver". En regardant les sections 'sélecteur' et 'ports', nous voyons que ce service va s'exécuter au-dessus du NCache Modules de serveur.
Je vais maintenant créer la ressource Cache Discovery Service dans mon cluster EKS en utilisant le 'kubectl appliquer' commande. Maintenant que le service a été créé, regardons sa description. Nous pouvons voir que les 'Endpoints' que le service résout pour contenir les adresses IP des NCache serveurs, avec les adresses IP affichées dans la section en surbrillance, étant les mêmes que les adresses IP affichées ici.
NCache Service de gestion
Nous allons utiliser le NCache Web Manager, pour créer notre cache en cluster et y ajouter des nœuds. Pour exposer le NCache Web Manager, nous allons déployer une autre ressource de service Kubernetes. Voici le fichier YAML pour le service Kubernetes, qui exposera le NCache gestionnaire de sites Web
Comme nous pouvons le voir, le 'nom' du service va être 'ncache' et dans la section 'ports', nous voyons que le port 80 va être mappé sur le port cible 8251, sur lequel le NCache Web Manager sera à l'écoute. En regardant la section "sélecteur", nous voyons que le service va s'exécuter au-dessus du NCache Modules de serveur. Ce service va être enregistré sur le backend de la ressource Ingress que nous déploierons plus tard et à partir de là, nous pourrons accéder au gestionnaire Web depuis notre navigateur.
Je vais maintenant créer le NCache ressource de service dans mon cluster EKS à l'aide de la 'kubectl appliquer' commander. Maintenant que le service a été créé, regardons à nouveau la description et nous voyons ici que les 'Endpoints' que le NCache auquel le service se résout, sont les adresses IP du NCache les serveurs.
NCache Entrée
Nous allons maintenant déployer la ressource Kubernetes Ingress qui exposera le NCache Web Manager depuis notre navigateur. La ressource Ingress va être implémentée par le contrôleur NGINX Ingress. le NCache service qui va être enregistré sur le backend de l'Ingress, permettra aux requêtes HTTP provenant de l'équilibreur de charge d'être acheminées vers le NCache Gestionnaire Web pour NCache fins de gestion. Voici le fichier YAML pour la ressource Ingress que nous allons déployer sur le cluster EKS.
Le 'nom' de l'entrée est 'ncache' et à partir des annotations, nous pouvons voir qu'il sera implémenté avec le contrôleur NGINX Ingress. De plus, ces annotations montrent que nous utiliserons des sessions persistantes avec le NCache Gestionnaire Web. Ainsi, pour ne pas rebondir sur les différentes instances de gestionnaire Web exécutées sur les différents NCache serveurs et nous sommes facilement en mesure de créer notre cache en cluster et d'y ajouter des nœuds au cours de la même session. Dans la section des règles, nous voyons que le chemin racine de l'URL va mapper sur le NCache service, qui expose le NCache Gestionnaire Web.
Nous allons maintenant créer la ressource Ingress sur notre cluster EKS. Maintenant que l'entrée a été créée, vérifions son statut. Nous voyons maintenant que l'Ingress est opérationnel. Vérifions l'URL de l'Ingress. L'URL est donnée dans la section 'Adresse'. Si je copie cette URL sur mon navigateur, je pourrai accéder à mon Web Manager. Donc, en venant sur mon navigateur, en cliquant ici et en collant l'URL et maintenant nous avons réussi à accéder au NCache Web Manager depuis le cluster Kubernetes.
Créer un cluster de cache
Nous allons maintenant créer notre cache clusterisé. Je vais maintenant passer par les étapes de création d'un cache en cluster à l'aide du NCache Gestionnaire Web. Donc, pour commencer, cliquez sur le bouton "Nouveau" affiché ici.
Nous allons maintenant donner un nom au cache groupé, 'democache', cliquez sur 'Suivant'.
Nous allons utiliser la partition de topologie Replica, en mode 'Asynchrone'.
Et maintenant, je vais ajouter le NCache serveurs vers le cache en cluster. Donc, cliquez sur le bouton '+' et ajoutez également l'autre serveur. Une fois les deux serveurs ajoutés, cliquez sur "Suivant".
Gardez tout par défaut et à la fin cliquez sur 'Terminer'. Nous voyons ici maintenant sur la fenêtre principale que le 'democache' a été créé avec succès.
Pour le démarrer, cochez la case à côté du nom du cache et appuyez sur 'Démarrer'.
Le cache a été démarré avec succès. Je vais maintenant cliquer sur l'onglet 'Moniteur' pour ouvrir le NCache outil de suivi.
Tout d'abord, dans la section 'Cluster Health', nous voyons que le cache en cluster est entièrement connecté.
Nous voyons ici différents compteurs de performances côté serveur. Dans la section 'Count', nous voyons que le compte est 0, car nous n'avons démarré aucune application cliente. En venant au 'Tableau de bord client', ici vous pourrez surveiller le NCache compteurs de performances côté client.
Dans le « Tableau de bord des rapports », vous obtenez une vue d'ensemble des compteurs côté serveur et côté client.
Déployer et exécuter des applications client
Une fois le cache en cluster créé, nous allons maintenant exécuter nos applications clientes. Voici le fichier YAML, qui sera utilisé pour déployer les applications clientes sur le cluster EKS.
Comme le montre la ressource de déploiement, qui porte le nom de client, nous aurons un pod, sur lequel les applications clientes seront exécutées. L''image' utilisée est montrée ici, elle contient à la fois le .NET Core et les applications Java ainsi que les NCache l'installation du client, afin que nous puissions collecter le côté client NCache compteurs de performances. Je vais maintenant déployer mes ressources client sur le cluster EKS. Maintenant que les ressources ont été créées. Vérifions l'état du pod client. La première chose que nous allons faire est de commencer le .NET Core Application. Dans le pod client, je vais exécuter la commande Shell suivante, "/app/testerdotmet/run.sh serveur de cache démocache" qui prend deux paramètres, à savoir le nom du cache, qui est 'democache' et le nom du service sans tête, qui est 'cacheserver'.
Et nous voyons maintenant que le .NET Core l'application est en cours d'exécution. En venant au NCache Surveillez, nous voyons dans la section 'Santé du cluster' que nous avons 1 client et nous constatons une reprise de l'activité de compteur. Le nombre augmente, puisque le .NET Core l'application vide les données dans le cache et dans la section "Processus client", voici l'adresse IP du pod sur lequel le .NET Core l'application est en cours d'exécution, ainsi que l'ID de processus de l'application. En ce qui concerne le "tableau de bord client", nous voyons ici que nous avons des compteurs côté client, provenant du pod client.
Dans le « Tableau de bord des rapports », nous obtenons une vue d'ensemble de ces compteurs de performances côté serveur et côté client.
Maintenant que la .NET Core l'application est en cours d'exécution, nous allons maintenant démarrer l'application Java. Tout comme avec le .NET Core application, dans le pod client, je vais exécuter la commande shell suivante, qui prend les mêmes paramètres que le .NET Core application, à savoir le nom du cache et le nom du service sans tête.
Et nous voyons ici que l'application Java est en cours d'exécution. Revenant à la NCache moniteur, nous voyons ici maintenant qu'il y a 2 clients et en descendant dans la section "Processus client", nous voyons une autre entrée pour le processus client, qui est liée à l'application Java. Ainsi, avec cela, nous avons pu confirmer que les applications peuvent se connecter avec le NCache serveurs s'exécutant sur le même cluster Kubernetes.
Mise à l'échelle NCache Grappe
Nous allons maintenant mettre à l'échelle notre NCache Groupe. La première chose que je vais faire est de mettre à l'échelle NCache déploiement à 3, de sorte que j'ai un autre serveur à ajouter au cluster de cache. Maintenant que le déploiement a été mis à l'échelle, regardons les adresses IP du serveur Pod et ici nous voyons un autre NCache serveur ajouté au cluster Kubernetes.
Et pour ajouter le nouveau serveur de cache, je vais cliquer sur le lien "Afficher les détails", devant le nom du cache.
En descendant à la section "Noeuds de serveur", je vais cliquer sur le bouton "Ajouter" et donner l'adresse IP du 3ème serveur.
Maintenant que le serveur a été ajouté, je vais le démarrer et pour cela je vais cocher la case à côté de l'adresse IP et cliquer sur 'Démarrer'.
Maintenant que le serveur de cache a démarré, revenons à la fenêtre principale et ici nous voyons 3 serveurs pour le 'democache'.
En venant à la fenêtre du moniteur et dans la section "Compter", le nombre par nœud a chuté en raison de la stratégie d'équilibrage de charge en vigueur.
Pour revenir à la fenêtre principale, je vais cliquer sur le bouton points de suspension à côté du nom du cache, puis sélectionner "Afficher les statistiques", afin que je puisse obtenir une autre vue du cluster de cache. Ici, nous voyons les partitions actives et répliquées, assurant la fiabilité, en ayant les données dans 1 nœud de serveur, sauvegardées par un autre nœud de serveur, dans le même cluster de cache.
Ceci nous amène à la fin de cette présentation. Si vous avez des questions sur la démonstration qui a été effectuée aujourd'hui, ou si vous souhaitez en savoir plus sur les différentes fonctionnalités qui NCache fournit, n'hésitez pas à nous contacter au support@alachisoft.com. Merci.