Partout dans le monde, la victoire de la conteneurisation sur la virtualisation a apporté performance et fiabilité entre les applications exécutées dans différents environnements informatiques. Le concept des conteneurs est qu'ils isolent les codes logiciels et toutes leurs dépendances pour assurer l'uniformité et la cohérence de toute infrastructure. Amazon, tout comme de nombreuses autres plates-formes cloud, fait rapidement évoluer ses services Elastic Kubernetes pour répondre aux besoins informatiques croissants des clients AWS.
Bien qu'Amazon Elastic Kubernetes Service soit en soi un service Kubernetes entièrement géré, sécurisé et fiable, il nécessite encore de nombreuses configurations manuelles pour gérer les clusters. Pour garantir les performances de votre application dans un tel environnement, vous devez utiliser NCache. NCache est une solution de mise en cache en mémoire qui améliore les performances de votre application et induit une évolutivité en améliorant la latence dans votre cluster EKS.
NCache Détails Déploiements de conteneurs NCache Documents EKS
NCache Architecture de déploiement dans Elastic Kubernetes Service
La structure de base de la façon dont NCache s'intègre dans votre cluster EKS est très simple. Vous disposez d'un équilibreur de charge classique sur le cloud AWS qui achemine les requêtes HTTP vers un contrôleur d'entrée s'exécutant dans le cluster EKS. À l'intérieur de ce cluster, vous avez votre cluster de cache en cours d'exécution NCache serveurs à l'intérieur de plusieurs pods. Ces pods sont mappés à un Service de découverte de cache qui autorise l'accès client aux pods de cluster qui exécutent le service de cache. Vous pouvez avoir plusieurs applications déployées sur plusieurs pods et elles seront toutes connectées au cluster de cache via ce service de découverte de cache.
Au sein de ce cluster EKS, vous disposez également d'un NCache Passerelle de surveillance à distance un service. Il s'agit d'un contrôleur d'entrée NGINX qui fournit des configurations d'équilibreur de charge pour ramener le trafic vers des pods spécifiques avec des sessions permanentes activées. La partie restante du cluster comprend diverses applications client, chacune dans son propre environnement de déploiement.
Le flux de requêtes et la structure d'un cluster EKS avec NCache déployé dans celui-ci est illustré dans le schéma ci-dessous.
NCache Détails Déploiements de conteneurs NCache Documents EKS
Alors, sans plus tarder, laissez-moi vous guider pas à pas dans un guide simple sur la façon dont vous pouvez déployer NCache dans votre cluster AWS Elastic Kubernetes.
Étape 1: Créer NCache Ressources
Pour utiliser toutes les fonctionnalités NCache vous fournit à l'intérieur de votre cluster Amazon Kubernetes, votre étape immédiate devrait être de déployer NCache ressources à l'intérieur d'EKS. Déploiement NCache vous permettra d'effectuer toutes les opérations de gestion de votre cluster.
Vous pouvez déployer NCache à l'aide de certains fichiers YAML. Chacun de ces fichiers contient des informations spécifiques qui participent au bon fonctionnement de NCache à l'intérieur d'EKS. Ces fichiers sont :
- NCache Fichier de déploiement : Ce fichier contient la spécification réelle des pods et des images requis qui doivent être utilisés. Ces informations incluent le nombre de répliques, le référentiel d'images, les ports requis, etc.
- NCache Fichier SAV : Ce fichier crée un service au-dessus du déploiement. L'objectif principal de ce fichier est d'exposer le déploiement à partir du serveur.
- NCache Fichier d'entrée : Ce fichier contient les informations nécessaires pour créer une session persistante entre une application cliente et Web Manager s'exécutant dans le cluster Kubernetes.
Voici les déploiements YAML de base dont vous avez besoin pour déployer NCache services à l'intérieur de votre cluster EKS. Parmi tous ces fichiers, le plus important est NCache Fichier YAML de déploiement. Ce fichier ressemble à ceci :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
kind: Deployment apiVersion: apps/v1beta1 metadata: name: ncache-deployment labels: app: ncache spec: replicas: 2 template: metadata: labels: app: ncache spec: nodeSelector: "beta.kubernetes.io/os": linux containers: - name: ncache image: docker.io/alachisoft/ncache:enterprise-server-linux-5.0.2 ports: - name: management-tcp containerPort: 8250 - name: management-http containerPort: 8251 - name: client-port containerPort: 9800 |
Une fois que vous avez créé ce déploiement en exécutant la commande suivante dans l'AWS CLI, Kubernetes créera le nombre exact de pods mentionné sous le répondre étiqueter. Sur chacun de ces pods, vous aurez un conteneur en cours d'exécution. L'image à partir de laquelle ce conteneur est fabriqué est fournie avec le image clé. Dans votre cas, ce sera le chemin vers le NCache enterprise serveur placé sur Docker HubL’ ports tag contient tous les ports qui doivent être exposés pour NCache services pour fonctionner dans le cluster.
1 |
kubectl create -f [dir]/filename.yaml |
Reportez-vous à NCache documents sur Création NCache Ressources dans EKS.
NCache Détails Déploiements de conteneurs NCache Documents EKS
Étape 2: Créer NCache Service Découverte
L'étape précédente vous amène à configurer le côté serveur de NCache. Une fois que cela a été exécuté avec succès, vous devez travailler sur la création d'un service de découverte qui expose votre NCache ressources aux applications clientes.
En dehors du cluster Kubernetes, des adresses IP statiques sont requises pour une communication client réussie. Aussi pratique que cela puisse être, à l'intérieur du cluster Kubernetes, chaque pod déployé se voit attribuer une adresse IP dynamique au moment de l'exécution qui reste inconnue des clients. Cette anomalie provoque des problèmes de communication à l'intérieur du cluster, où les applications clientes ne parviennent pas à identifier NCache les serveurs. Ici, le besoin d'un service de découverte sans tête à l'intérieur de votre cluster EKS pour vous NCache clients se pose.
Ce service sans tête résout ce problème en exposant les adresses IP des NCache serveurs aux applications clientes. Ces clients utilisent ces adresses IP pour créer les descripteurs de cache requis et pour commencer à effectuer des opérations de cache.
Pour permettre à tous les clients de se connecter facilement au service sans tête, créez et déployez un fichier Cache Discovery YAML comme indiqué :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
kind: Service apiVersion: v1 # depends on underlying Kubernetes version metadata: name: cacheserver labels: app: cacheserver spec: clusterIP: None selector: app: ncache # same label as provided in the ncache deployment yaml ports: - name: management-tcp port: 8250 targetPort: 8250 - name: management-http port: 8251 targetPort: 8251 - name: client-port port: 9800 targetPort: 9800 |
Ce qui fait de ce service un service sans tête, c'est la balise clusterIP réglé sur "Aucun". Ce comportement indique que ce service est spécifique à NCache et ne sera pas accessible en dehors du cluster EKS. Étiqueter sélecteur ajuster à ncache aide ce service à identifier tous les pods dont l'étiquette est ncache afin que leurs adresses IP puissent être exposées aux clients.
Un petit aperçu du fonctionnement : pour le client qui se connecte aux serveurs, une seule adresse IP suffit, car le serveur auquel il se connecte partage les adresses IP de tous les serveurs qui font partie de ce cluster de cache.
Une fois le fichier prêt à être déployé, exécutez la commande suivante dans l'interface de ligne de commande AWS.
1 |
kubectl create -f [dir]/cachediscovery.yaml |
Pour un déploiement détaillé étape par étape, suivez notre documentation sur Créer un service de découverte.
NCache Détails Déploiements de conteneurs NCache Documents EKS
Étape 3 : Créer un accès pour NCache Gestion
Pour exposer permettre NCache l'accès de gestion depuis l'extérieur du cluster, vous devez configurer un contrôleur d'entrée. Ce contrôleur résume les stratégies d'équilibrage de charge de base que vous utilisez normalement dans les déploiements de conteneurs. Un contrôleur d'entrée fréquemment utilisé est le contrôleur NGINX qui, une fois déployé, est responsable de la création de tous les services nécessaires pour exposer NCache services extérieurs au cluster.
Pour déployer le contrôleur d'entrée NGINX dans votre cluster EKS, vous devez y créer plusieurs déploiements de fichiers. Ces fichiers contiennent toutes les informations nécessaires à votre cluster Kubernetes pour installer un équilibreur de charge NGINX entièrement fonctionnel.
Vous trouverez ci-dessous la liste des fichiers requis avec une brève explication de ce qu'ils font et pourquoi ils sont nécessaires :
- Fichier obligatoire NGINX : Ces fichiers sont les fichiers de base nécessaires dont vous avez besoin pour exécuter le contrôleur NGINX ; qui dans votre cas sera un équilibreur de charge à l'intérieur de votre cluster EKS. Vous pouvez trouver ce fichier sur GitHub.
- Fichier de service NGINX : Ce fichier contient les informations sur l'équilibreur de charge layer7 qui expose le contrôleur d'entrée NGINX à l'extérieur de l'environnement Kubernetes.
- Fichier de configuration NGINX : Ce fichier contient tous les paramètres requis pour configurer l'équilibreur de charge Layer7.
Parmi les fichiers susmentionnés, Service NGINX YAML est le fichier qui contient les informations de ports nécessaires pour créer un équilibreur de charge conscient de NCache accès de gestion. Le contenu de ce fichier est présenté ci-dessous :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
kind: Service apiVersion: v1 metadata: name: ingress-nginx namespace: ingress-nginx labels: app.kubernetes.io/name: ingress-nginx app.kubernetes.io/part-of: ingress-nginx annotations: ... spec: type: LoadBalancer selector: app.kubernetes.io/name: ingress-nginx app.kubernetes.io/part-of: ingress-nginx ports: - name: http port: 80 protocol: TCP targetPort: http - name: https port: 443 protocol: TCP targetPort: http |
Tous ces fichiers sont créés en tant que fichiers YAML qui sont très facilement déployés à l'intérieur du cluster EKS. Tout ce que vous avez à faire est d'exécuter la commande suivante pour chaque fichier dans l'outil de ligne de commande configuré AWS.
1 |
kubectl create -f [dir]/<filename>.yaml |
Lors de l'exécution, cette commande créera un équilibreur de charge qui permet la permanence à l'intérieur de votre cluster. Pour plus d'informations, reportez-vous à notre documentation sur Créer un accès pour NCache Gestion.
NCache Détails Déploiements de conteneurs NCache Documents EKS
Étape 4 : Créer un cluster de cache
Maintenant que vos déploiements et services collectifs sont en place, vous devez créer un NCache cluster pour permettre à vos clients de se connecter aux serveurs de cache.
Lorsque vous avez déployé NCache service, vous avez secrètement déployé NCache Web Manager est également entièrement intégré au NCache opérations de gestion. Vous pouvez utiliser ceci NCache Web Manager pour créer votre cache en cluster et jouer avec. Tout ce que vous avez à faire est de suivre ces étapes de base fournies dans NCache documents sur Créer un cache en cluster et vous êtes prêt à partir! Ici, cependant, ce qui nécessite votre plus grande concentration, c'est que les adresses IP des nœuds de serveur que vous devez ajouter doivent être les mêmes que les adresses IP des pods de serveur attribués par le cluster Kubernetes. Vous pouvez obtenir la liste de ces IPs et leur détail en exécutant le obtenir des gousses commande dans l'outil de ligne de commande AWS.
Étape 5 : Créer un déploiement d'application client
NCache déploiement client, tout comme NCache déploiement de ressources, spécifie le nombre de conteneurs d'images client en cours d'exécution, le référentiel Dockerhub privé où l'application est placée, les ports, etc. Ces informations vous aident à créer un conteneur client entièrement fonctionnel.
Pour obtenir l'application cliente à partir d'un référentiel privé, vous devez mentionner à chaque fois les identifiants de connexion. Pour vous épargner de ce tracas, vous pouvez créer un secrets.yaml fichier qui contient vos informations de connexion qui doivent être renseignées une fois et qui est accessible à chaque ressource cliente appelante. Faire référence à NCache documents sur Créer un déploiement client pour obtenir une vue détaillée des étapes et des fichiers YAML.
De même, le déploiement réel du client est également créé sous la forme d'un fichier YAML. Ce fichier contiendra toutes les informations nécessaires pour déployer votre application cliente (ou vos applications ; votre appel) dans votre cluster EKS. Le contenu de ce fichier est présenté ci-dessous :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
kind: Deployment apiVersion: apps/v1beta1 # it depends on the underlying Kubernetes version metadata: name: client spec: replicas: 1 template: metadata: labels: app: client spec: nodeSelector: "beta.kubernetes.io/os": linux containers: - name: client image: # Your docker client image here ports: - name: app-port containerPort: 80 # In case of NCache client installation, add the following remaining ports - name: management-tcp containerPort: 8250 - name: management-http containerPort: 8251 - name: client-port containerPort: 9800 |
Lorsqu'il s'agit de déployer les conteneurs à partir de l'image, le processus qui suit se déroule comme suit :
1. L'image est accessible depuis le référentiel.
2. Le fichier de secrets client est lu à partir du NCache ressource secrète pour l'authentification.
3. L'image est extraite et déployée dans un conteneur dans lequel l'application cliente s'exécute.
Ici, comme nous avons un déploiement et non un service, ce que vous devez faire est d'aller dans le pod et d'exécuter la commande batch dans AWS CLI pour commencer à exécuter l'application cliente.
1 |
kubectl exec --namespace=ncache client-podname -- /app/<clientapplication>/run.sh democlusteredcache cacheserver |
NCache Détails Déploiements de conteneurs NCache Documents EKS
Étape 6: Surveiller NCache Grappe
Jusqu'à présent, vous avez fait tout ce dont vous avez besoin pour tirer le meilleur parti de NCache à l'intérieur de votre cluster Amazon EKS entièrement fonctionnel et en cours d'exécution. Vous bénéficiez d'une haute disponibilité, d'une évolutivité, d'une fiabilité, etc. simplement en déployant NCache dans le cluster. Mais devinez quoi ? Ce n'est pas tout ça NCache des offres.
Écoutez-moi. Au sein du cluster EKS, au milieu de toutes les opérations, du stockage et du transfert de données, NCache vous permet de surveiller l'activité du cache à travers divers outils. Ces outils vous aident à avoir une meilleure idée de la santé, des performances, des problèmes de réseau, etc. de votre cluster.
Vérifier NCache Moniteur Web pour une représentation graphique des performances en temps réel et NCache Statistique pour les statistiques de performances.
Étape 7 : mise à l'échelle NCache Grappe
Pour vous offrir une évolutivité extrême, NCache vous permet d'augmenter ou de réduire votre cluster lors de l'exécution pour améliorer les performances globales de votre application. Par exemple, si vous pensez que le cluster de cache reçoit des requêtes trop fréquemment pour que les nœuds puissent suivre l'augmentation des transactions, NCache vous permet d'ajouter plusieurs serveurs pour s'adapter à la charge. Pour voir comment vous pouvez ajouter ou supprimer des nœuds de serveur du cluster de cache lors de l'exécution tout en restant à l'intérieur du cluster EKS, consultez notre documentation sur Ajout d'un serveur de cache dans EKS ainsi que Suppression des serveurs de cache d'EKS.
Allons tout remonter
À partir de cet article, vous devez découvrir une procédure pas à pas de NCache déploiement dans un cluster Amazon EKS. La principale question ici est pourquoi avez-vous besoin NCache dans un environnement de conteneur déjà complet ? Eh bien, laissez-moi vous résumer très rapidement.
- Solution en mémoire : NCache augmente les performances de votre application déployée par un facteur notable.
- Évolutivité linéaire : NCache est pratique lorsque la charge sur votre cluster de cache augmente.
- Extrême flexibilité : NCache rééquilibre automatiquement et dynamiquement les données sans aucune intervention du client.
Vous mettez tout cela en plus des fonctionnalités déjà fournies par AWS EKS et vous disposez d'un environnement de premier ordre pour exécuter votre application. Alors, qu'attendez-vous ? Déployer NCache dans votre cluster EKS dès maintenant et soyez témoin de la magie par vous-même.