L'introduction de la technologie des conteneurs a considérablement amélioré la facilité de développement d'applications, et Kubernetes est à l'avant-garde de ces progrès. Kubernetes est une plateforme open source qui gère l'orchestration de vos conteneurs sur plusieurs machines. L'une de ces plates-formes Kubernetes, Red Hat OpenShift (par Red Hat), offre aux utilisateurs la possibilité de faire évoluer automatiquement les applications cloud. Il a des conteneurs d'applications alimentés par Docker avec des services d'orchestration et de gestion fournis par Kubernetes. En tant que tel, OpenShift gagne en popularité pour son architecture de conteneur simple. Il fournit une architecture de déploiement intégrée pour la gestion des conteneurs à l'aide des services d'orchestration Kubernetes. Par conséquent, plusieurs produits profitent de ce déploiement.
Par exemple, il est entièrement NCache-prise en charge. NCache est une solution de mise en cache distribuée en mémoire qui garantit des performances et une évolutivité élevées. Mettre en cache vos données avec NCache réduit vos trajets réseau et la charge sur votre base de données car vos données résident dans le cache, plus près de votre application. Dans cet article, nous nous concentrons sur les étapes nécessaires pour NCache déploiement dans Red Hat OpenShift.
NCache Détails NCache Déploiement dans OpenShift-Docs Utilisez NCache dans OpenShift-Vidéo
NCache Architecture de déploiement dans Red Hat OpenShift
Avec NCache, vous pouvez profiter de votre orchestration cloud basée sur l'environnement OpenShift avec des NCache fonctionnalités à l'aide d'une application de conteneur facile à gérer. Vous pouvez commencer avec un seul cluster Kubernetes avec différents déploiements d'applications et, surtout, le NCache déploiement de grappes. Actuellement, les applications de conteneur basées sur Docker exécutées dans l'environnement sont :
- Application Web Java
- Application de services Web Java
- ASP.NET Core application
Ces applications ont NCache installée; plus précisément, les applications Java utilisent des clients Java de NCache, alors qu'un déploiement séparé pour ASP.NET core applications utilise une image Docker sur Linux/Unix et employer le .NET Core client pour NCache la communication. Pour le déploiement côté serveur, il utilise un Docker basé sur Linux image pour NCache Disponible sur Docker Hub.
Les applications se connectent à un service appelé Cache Discovery Service - un service sans tête au sein de Kubernetes. Il sert à gérer l'acheminement et l'allocation des ressources qui font partie du NCache groupe. De même, une passerelle de surveillance à distance se connecte également à ce service pour permettre la surveillance du cluster de cache depuis l'extérieur de Kubernetes pour toutes les opérations telles que NCache gestion des caches.
Lorsque nous travaillons avec Kubernetes, nous utilisons des pods. Essentiellement, dans Kubernetes, les adresses IP sont attribuées aux pods. Un pod est un objet Kubernetes encapsulant l'instance de conteneur sous-jacente tout en agissant comme une couche virtuelle au-dessus d'un conteneur. Un seul pod peut avoir plusieurs conteneurs, mais il est fortement recommandé qu'un seul pod contienne un seul conteneur. En bref, toute l'allocation des ressources dans un cluster Kubernetes se produit sur le pod au lieu du conteneur.
Le schéma suivant donne une représentation globale du flux de l'architecture du NCache déploiement:
NCache Détails Premiers pas avec Docker DockerLinux
Étape 1: déployer NCache Serveurs
Déploiement NCache serveurs dans Red Hat OpenShift vous oblige à créer un fichier YAML avec votre NCache configurations. Ces déploiements YAML contiennent tous les composants de votre application et sont très faciles à déployer. Assurez-vous d'ajuster ces composants en fonction des exigences de votre application. Vous trouverez ci-dessous l'exemple de fichier YAML avec les configurations :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
apiVersion: apps/v1beta1 kind: Deployment metadata: name: ncache labels: app: ncache spec: replicas: 2 template: metadata: labels: app: ncache spec: containers: - name: ncache image: docker.io/alachisoft/ncache:latest ports: - name: management-tcp containerPort: 8250 - name: management-http containerPort: 8251 - name: client-port containerPort: 9800 |
Kubernetes évolue très rapidement et ne cesse de proposer de nouvelles fonctionnalités, ces fonctionnalités faisant rapidement partie de l'API principale. Cependant, plusieurs fonctionnalités ne suivent pas cette trajectoire en raison de leur nature expérimentale. Nous définissons donc "apiVersion" en conséquence. La version utilisée ici est "v1beta1", qui dépend de la version sous-jacente de Kubernetes. Assurez-vous donc de ne pas utiliser une version obsolète.
Les ports mentionnés dans le fichier de déploiement incluent les éléments suivants :
- Port 8250: Pour la gestion TCP.
- Port 8251: Pour la gestion et la surveillance HTTP.
- Port 9800: Pour la communication entre les applications clientes se connectant à NCache.
Tout d'abord, nous définissons le type de déploiement. La prochaine chose est le nombre de répliques (2 dans ce cas), et vous pouvez l'augmenter selon votre logique. Pour plus de détails sur les répliques de pod, veuillez consulter ici. Pour les conteneurs, vous devez spécifier l'image Docker en fournissant le chemin du NCache Enterprise Image Server Linux Docker disponible sur Docker Hub. La commande générale pour extraire cette image Docker est :
1 |
docker pull alachisoft/ncache:latest |
Une fois que vous avez créé le fichier YAML avec toutes les configurations nécessaires, vous devez importer le fichier à l'aide de la console Web OpenShift. Créez un nouveau projet avec un nom de votre choix et importez le fichier YAML dans le projet contenant le NCache déploiements. Vous pouvez également utiliser le Outil CLI OpenShift, qui affiche l'état des déploiements.
NCache Détails NCache Scénarios de déploiement Docker de transfert de port
Étape 2 : Créer un service de découverte de cache
Comme établi précédemment, le service de découverte de cache est responsable de l'acheminement de tous les NCache communication avec les pods sous-jacents. Ce service de découverte agit comme la passerelle de communication centrale entre les applications client et NCache les clusters de cache qui font partie du cluster Kubernetes. De plus, il s'agit d'un service sans tête et récupère les adresses IP du sous-jacent NCache pods de serveur de cache dans le cluster Kubernetes.
Pour créer un tel service, vous devez créer un autre YAML, comme illustré ci-dessous :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
apiVersion: v1 kind: Service metadata: name: cacheserver labels: app: cacheserver spec: clusterIP: None sessionAffinity: ClientIP selector: app: ncache ports: - name: management-tcp port: 8250 targetPort: 8250 - name: client-port port: 9800 targetPort: 9800 |
Ici, il est nommé serveur de cache. Cependant, vous pouvez vous y référer en fonction de vos configurations. Dans ce cas, le "genre" est service. De plus, il contient les ports avec le nom et les numéros de port nécessaires à la communication avec le service de découverte. La "sessionAffinity" est définie sur ClientIP, ce qui garantit que les opérations de gestion et de surveillance en dehors du cluster Kubernetes sont adhérentes à l'un des pods à un moment donné. Après avoir créé le fichier YAML, importez ce fichier via l'assistant et il créera automatiquement votre service de découverte de cache, comme indiqué dans l'image ci-dessous.
Étape 3 : Créer une passerelle de gestion
Cette étape organise la gestion et la surveillance des opérations en dehors du cluster Kubernetes. Toutes les opérations de gestion en cours sont acheminées via cette passerelle vers ce service de découverte de cache, ce qui, à son tour, vous aidera également à gérer et à surveiller tous les pods sous-jacents.
Pour créer la passerelle de gestion :
- Accédez à la section "Réseau" du portail OpenShift.
- Choisissez un "Itinéraire" dans le menu déroulant.
- Créez une route vers le service sans tête, c'est-à-dire le service de découverte de cache.
- Donnez un nom à la route et sélectionnez le service "cacheserver" créé à l'étape précédente. De plus, fournissez le port cible 8251 pour la gestion et la surveillance en dehors du cluster Kubernetes.
5. Une fois créé, choisissez le chemin d'emplacement redirigeant vers NCache Web Manager sur l'un des pods du serveur de cache pour "Emplacement".
Étape 4 : Créer un cluster de cache
Maintenant que nous avons déployé avec succès NCache dans Red Hat OpenShift, nous pouvons créer un cluster de cache en utilisant NCache Web Manager.
Créez le cluster de cache en suivant les étapes du Documentation et assurez-vous que les adresses IP utilisées sont les adresses IP de vos pods de cache. Pour obtenir les adresses IP des pods de cache, accédez à la section "Pods" de la console Web OpenShift ou de l'outil de ligne de commande. Une fois la création de cache est terminée, démarrez le cache en utilisant NCache Web Manager.
NCache Détails Créer un cluster de cache Opération de gestion du cache
Étape 5 : Déployer les applications clientes
Vous pouvez maintenant déployer et exécuter vos applications clientes en créant un fichier YAML contenant le déploiement pour les clients. Nous importons ce fichier de déploiement à l'aide du portail OpenShift. Les applications clientes peuvent être .NET Core ou Java selon les besoins.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
apiVersion: apps/v1beta1 kind: Deployment metadata: name: clientapp labels: app: clientapp spec: replicas: 1 template: metadata: labels: app: clientapp spec: containers: - name: clientapp image: your-client-application-repo-path ports: - name: management-tcp containerPort: 8250 |
Ici, pour se connecter au cache, nous n'avons pas besoin des adresses IP des pods de cache. Le service de découverte de cache que nous avons créé avec le nom "cacheServer" fournit l'adresse IP des pods de cache à notre application cliente lors de l'exécution. La NCache client a cette logique intégrée pour parler à son service nommé et découvrir automatiquement toutes les ressources sous-jacentes au sein de la plate-forme OpenShift Kubernetes.
D'où le NCache client est suffisamment intelligent pour se connecter à un cluster entièrement connecté en fournissant le nom du service.
Étape 6 : Surveillance NCache Grappe
NCache est livré avec divers outils pour vous aider à surveiller votre cluster de cache. La surveillance de votre cluster de cache vous donne des informations en temps réel sur la santé du cluster, l'activité du cache, le nombre d'opérations en cours et bien plus encore. Vous pouvez également surveiller votre cluster de cache pour prendre les mesures appropriées en cas de perturbation du réseau, de surcharge de mémoire, etc.
NCache Web Manager est un outil de gestion fourni par NCache pour configurer les caches et surveiller leurs performances. De la même manière, NCache Moniteur Web est un outil de gestion Web qui vous permet de surveiller les performances du cache en temps réel.
Étape 7 : mise à l'échelle NCache Grappe
NCache est un système de mise en cache distribué avec une architecture très évolutive. Ainsi, pour obtenir une capacité et une fonctionnalité améliorées pour NCache dans votre environnement OpenShift, vous pouvez faire évoluer votre NCache cluster en ajoutant plus de pods. Il existe plusieurs façons d'y parvenir. En commençant par le portail Web OpenShift :
- Allez dans "Déploiements".
- Cliquez sur le bouton "Modifier le nombre".
- Augmentez le nombre de pods en cliquant sur le bouton "+".
En procédant automatiquement à ces étapes, le nombre de réplicas dans votre fichier de déploiement augmente, en fonction du nombre de pods ajoutés. Elle peut aussi se faire à l'aide Outil OpenShift CLI (oc).
Notez qu'en ajoutant ces pods, vous créez un autre pod, mais il ne fait pas partie du cluster par lui-même. De manière à ajouter des serveurs de cache à un cluster de cache en cours d'exécution, accédez à la page Nœuds de serveur à partir de NCache Web Manager et ajoutez une adresse IP de serveur pour ajouter ce nœud de serveur dans le cluster. Un nœud de serveur est ajouté à votre cluster de cache au moment de l'exécution et améliore considérablement les performances avec NCacheest facile à mettre à l'échelle.
NCache Détails NCache Déploiement dans OpenShift Utilisez NCache dans OpenShift
Conclusion
Essentiellement, NCache déploiement dans Red Hat OpenShift est une procédure par étapes facile à suivre. La conteneurisation est une nécessité technologique émergente du monde d'aujourd'hui pour la légèreté qu'elle offre. NCache est une solution de mise en cache distribuée extrêmement rapide, et avec Red Hat OpenShift, vous pouvez facilement gérer votre cluster Kubernetes conteneurisé. Alors, entrez dans le monde de NCache pour exécuter vos applications sur le cluster Kubernetes en quelques étapes simples.