Die richtigen NCache im AWS Elastic Kubernetes Service (EKS)
Elastischer Kubernetes-Cluster mit Docker-Containern
AWS Elastic Kubernetes Service (EKS) ist ein von Amazon Web Services (AWS) verwalteter Kubernetes-Service, mit dem Sie Ihren Kubernetes-Cluster zusammen mit den neuesten Patches und Upgrades der zugrunde liegenden Infrastruktur einrichten können, die ihn unterstützt.
Wenn Sie mit .NET/.NET Core oder Java-Anwendungen, die in EKS ausgeführt werden und die Sie verwenden möchten NCache Wenn Sie ihre Leistung und Skalierbarkeit bei Spitzentransaktionslasten verbessern möchten, können Sie sich darauf verlassen NCache unterstützt dieses Umfeld voll und ganz.
Sehen Sie sich dieses Video an, um zu sehen, wie einfach die Bereitstellung ist NCache in Ihren Amazon Elastic Kubernetes-Cluster.
NCache Einsatz im EKS
In der AWS Cloud haben wir einen klassischen Load Balancer vor einem Ingress Controller, der innerhalb des Kubernetes Clusters läuft. Die von diesem Ingress-Controller implementierte Kubernetes-Ingress-Ressource leitet die vom Load Balancer kommenden HTTP-Anfragen an die verschiedenen im Cluster ausgeführten Dienste weiter. Nun benötigen wir in solchen verteilten Anwendungsumgebungen auch eine verteilte Caching-Lösung, die Skalierbarkeit, Zuverlässigkeit und hohe Verfügbarkeit bietet, wenn schnelle Lesevorgänge ausgeführt werden, und genau das ist der Fall NCache kommt in.
NCache kann in Ihrem EKS-Cluster bereitgestellt werden als NCache Server, die in Linux-Containern ausgeführt werden und diese Container in den Kubernetes-Pods gehostet werden. Die IP-Adressen davon NCache Server werden von der aufgelöst Cache-Erkennungsdienst, bei dem es sich um einen Headless-Dienst von Kubernetes handelt, und die IP-Adressen von dort werden von den Clientanwendungen verwendet, um Cache-Handles zu erstellen, mit denen sie eine Verbindung zum herstellen können NCache Cluster und beginnen Sie mit der Durchführung von Verwaltungs- und CRUD-Vorgängen.
Im Folgenden sind die wichtigen Parameter der Demonstration aufgeführt, die wir heute durchführen werden. Der NCache Server, die im EKS-Cluster bereitgestellt werden, verwenden das folgende Docker-Image 'alachisoft/ncache' mit einem Tag von 'enterprise-server-linux-5.0.2'.
Um alle Bilder zu bekommen NCache bietet, lass mich zu dem kommen Alachisoft Webseite. Wähle aus 'Herunterladen' Tab und klicken Sie dann auf „NCache'. Dies bringt Sie zum NCache Download-Center. Wenn ich nach unten zum Abschnitt „Docker Hub“ scrolle, klicke ich einfach auf den zweiten Eintrag von oben und werde dann weitergeleitet Docker-Hub Seite von Alachisoft NCache. Hier können Sie alle Bilder sehen, die NCache bietet. Zurück zu den Parametern: Das Bild, das verwendet wird, hat die folgenden Eigenschaften: NCache Enterprise 5.0 SP2 Edition mit a .NET Core Installation. Der Cluster-Cache, den wir erstellen werden, verwendet die Partition der Replikat-Topologie. Die beiden Testanwendungen, die verwendet werden, sind wie folgt. Wir haben einen .NET Core Anwendung und eine Java-Anwendung und in beiden Fällen zeigen wir den App-Daten-Caching-Aspekt von NCache. Wir beginnen mit 2 NCache Servern und erhöhen Sie diese Zahl dann auf 3. Um dies zu demonstrieren, können wir dynamische Änderungen in den vornehmen NCache Clusterstatus ohne Auswirkungen auf die Clientleistung.
Erstellen Sie einen EKS-Cluster
Wir sind jetzt bereit, mit unserer Demonstration zu beginnen. Als Erstes müssen wir natürlich die EKS-Infrastruktur einrichten, auf der wir unsere bereitstellen werden NCache Server- und Clientressourcen. Hier befinde ich mich auf der AWS-Einstiegsseite für den EKS-Service. Hier finden Sie alle Informationen, die Sie benötigen, um Ihren ersten EKS-Cluster zum Laufen zu bringen. Die Informationen umfassen die Voraussetzungen wie die erforderliche IAM-Rolle und Richtlinien.
Darüber hinaus wird detailliert auf die Erstellung einer VPC eingegangen, auf der Sie Ihren EKS-Cluster bereitstellen.
Weiter unten finden Sie Informationen zur Installation und Nutzung der AWS CLI und der Befehlszeilendienstprogramme „kubectlc“ für den Zugriff und die Verwaltung des Kubernetes-Clusters.
Außerdem sind Informationen zur von Kubernetes verwalteten Knotengruppe enthalten, die die Worker-Knoten bereitstellt, auf denen Sie Ihre Kubernetes-Ressourcen bereitstellen. Ich werde die hier gegebenen Informationen verwenden, um einen EKS-Cluster auf einer VPC mit zwei öffentlichen und zwei privaten Subnetzen zu erstellen. Sobald mein EKS-Cluster betriebsbereit ist, werde ich mit dem Rest der Demonstration fortfahren.
Mit diesen Schritten auf der Seite „Erste Schritte“ habe ich bereits die IAM-Rollen und die VPC-Infrastruktur für meinen EKS-Cluster erstellt. Jetzt werde ich diese Schritte zum Erstellen der EKS-Infrastruktur durchgehen.
Dazu befinde ich mich auf meiner AWS-Verwaltungskonsole und klicke auf den Link „Elastic Kubernetes Service“. Dadurch komme ich zur Hauptseite des EKS-Dienstes. Unterhalb der Überschrift „Amazon EKS“ im linken Bereich der Seite klicke ich auf den Link „Cluster“.
Im Moment habe ich keinen EKS-Cluster. Dazu klicke ich auf den Link „Cluster erstellen“.
Hier werde ich die Konfigurationsparameter angeben. Ich beginne also mit dem Namen des EKS-Clusters, der „eks-“ lautet.ncache'. Ich werde „1.14“ für „Kubernetes-Version“ auswählen. Ich werde auch die „IAM-Rolle“ und die „VPC“ auswählen. Ich wähle die Sicherheitsgruppe aus und alles andere bleibt standardmäßig erhalten. Ich gebe dem EKS-Cluster ein Tag und sobald dies alles erledigt ist, klicke ich auf die Schaltfläche „Erstellen“.
Nun, dass die EKS-Cluster gerade erstellt wird, pausiere ich das Video, da dies einige Zeit dauern wird. Auf der Seite meines EKS-Clusters kann ich sehen, dass „eks-“ncache' ist aktiv'. Der zweite Schritt besteht darin, die verwaltete Knotengruppe zu erstellen. Dazu scrolle ich nach unten zum Abschnitt „Knotengruppen“ und klicke auf die Schaltfläche „Knotengruppe hinzufügen“.
Ich werde die Parameter eingeben, beginnend mit dem Namen der Knotengruppe, und ich werde die „IAM-Rolle“ auswählen.
Ich wähle das „SSH-Schlüsselpaar“ aus und klicke auf „Weiter“.
Hier verwende ich den folgenden „AMI-Typ“ und als „Instanztyp“ verwende ich „t3.small“. Danach klicke ich auf „Weiter“.
Ich wähle zwei Worker-Knoten aus und klicke auf „Weiter“.
Und nachdem ich mir die Parameter angesehen habe, klicke ich auf „Erstellen“, um mit der Erstellung meiner Knotengruppe zu beginnen. Wir sehen hier, dass sich die Knotengruppe gerade im Erstellungsstatus befindet, daher werde ich das Video anhalten. Hier sehen wir nun, dass meine EKS-Knotengruppe „Aktiv“ ist und die Erstellung meiner EKS-Infrastruktur abgeschlossen ist.
Im PowerShell-Terminal meines Client-Computers werde ich die AWS CLI verwenden, um meine „kubeconfig“-Datei zu erstellen, um Zugriff auf den EKS-Cluster zu erhalten, und die „kubeconfig“-Datei wurde erstellt. Jetzt bestätige ich meine Verbindung zum EKS-Cluster und wir sehen die beiden Worker-Knoten, die in der von EKS verwalteten Knotengruppe enthalten sind.
Stellen Sie den Ingress-Controller bereit
Als Erstes werde ich die für den Ingress Controller erforderlichen Kubernetes-Ressourcen bereitstellen. Kommen wir zum Architekturdiagramm: Der hier gezeigte Ingress-Controller wird zur Implementierung der Ingress-Ressource verwendet, die wir später bereitstellen werden.
In unserer Demonstration verwenden wir den NGINX Ingress-Controller aufgrund seiner Beliebtheit. Zunächst werden wir die obligatorischen Ressourcen bereitstellen, die erforderlich sind, um den NGINX Ingress Controller in jeder Kubernetes-Umgebung zum Laufen zu bringen, und anschließend werden wir die AWS-spezifischen Ressourcen bereitstellen, die einen klassischen Load Balancer vor dem NGINX Ingress starten Controller und ermöglichen Sie dem NGINX Ingress Controller, über diesen klassischen Load Balancer HTTP-Anfragen von außerhalb des Kubernetes-Clusters zu empfangen.
Ich werde jetzt die obligatorischen Ressourcen bereitstellen, die für den NGINX Ingress Controller erforderlich sind. Die Definitionen dieser Ressourcen finden Sie, indem Sie der URL folgen, die im hervorgehobenen Abschnitt angegeben ist. Lassen Sie uns also ohne weiteres loslegen und die erforderlichen Ressourcen wurden bereitgestellt. Hier habe ich die YAML-Datei geöffnet, die ich zum Bereitstellen von zwei Ressourcen im Zusammenhang mit dem NGINX-Ingress-Controller verwenden werde.
Die erste Ressource ist der Load-Balancer-Dienst, der zum Hochfahren eines klassischen Load-Balancers vor dem NGINX-Ingress-Controller verwendet wird. Wie wir dem Anmerkungsabschnitt entnehmen können, wird der Load Balancer auf Schicht 7 arbeiten und HTTP-Anfragen an den NGINX-Ingress-Controller weiterleiten. Die andere Ressource, die wir bereitstellen werden, ist die Ressource „ConfigMap“, die die Konfigurationsparameter für das Verhalten des NGINX-Ingress-Controllers innerhalb des Kubernetes-Clusters enthält.
Ich werde diese Ressourcen jetzt mithilfe von bereitstellen 'kubectl anwenden' Der Befehl wurde ausgeführt und die Ressourcen wurden bereitgestellt. Lassen Sie mich zu meinem EC2-Dashboard gehen und bestätigen, dass der Load Balancer hochgefahren wurde. Wenn ich diese Seite aktualisiere, wird ein neuer Load Balancer eingeführt. Lassen Sie mich auf den Link „Load Balancer“ klicken und hier ist der Load Balancer vor dem NGINX Ingress Controller.
Deploy NCache Fertige Server
Wir werden jetzt bereitstellen NCache Server zum EKS-Cluster. Kommen wir noch einmal zum Architekturdiagramm: Diese NCache Server werden verwendet, um den Cluster-Cache innerhalb des EKS-Clusters zu erstellen. Hier ist die YAML-Datei für die Bereitstellung NCache Server zum Kubernetes-Cluster. Wie wir sehen können, handelt es sich hierbei um eine Bereitstellungsressource, die hochgefahren wird NCache Server innerhalb des EKS-Clusters. Im Folgenden sind die Ports aufgeführt, auf denen die NCache Server werden zuhören. Wir haben den Port „management-tcp“ mit dem Wert 8250, auf dem die NCache Server warten auf Client-Verbindungsanfragen. Wir haben den Port „management-http“ mit dem Wert 8251, auf dem der NCache Web Manager wird lauschen und dann haben wir den 'Client-Port' mit einem Wert von 9800, auf dem der NCache Die Server warten auf CRUD-Vorgangsanforderungen des Clients.
Verwendung der 'kubectl anwenden' Befehl, ich werde jetzt den erstellen NCache Server-Pods auf meinem EKS-Cluster und überprüfen wir nun den Status der Pods. Die Pods laufen. Wir haben 2 NCache Server mit den hier angezeigten IP-Adressen.
NCache Erkennungsdienst
Wir werden jetzt die bereitstellen NCache Erkennungsdienst. Der Cache Discovery Service ist ein Headless-Dienst, der auf dem ausgeführt wird NCache Server-Pods. Seine Funktion besteht darin, die IP-Adressen aufzulösen, die von den Clientanwendungen verwendet werden, wenn sie eine Verbindung mit dem Cluster-Cache herstellen möchten.
Hier ist die YAML-Datei für den Kubernetes-Headless-Dienst. Wie wir sehen können, lautet der Name des Dienstes „Cacheserver“. Wenn wir uns die Abschnitte „Selektor“ und „Ports“ ansehen, sehen wir, dass dieser Dienst über dem ausgeführt wird NCache Server-Pods.
Ich werde jetzt die Cache Discovery Service-Ressource in meinem EKS-Cluster erstellen 'kubectl anwenden' Befehl. Nachdem der Dienst nun erstellt wurde, schauen wir uns seine Beschreibung an. Wir können sehen, dass die „Endpunkte“, die der Dienst auflöst, die IP-Adressen der enthalten NCache Servern, wobei die im hervorgehobenen Abschnitt angezeigten IP-Adressen mit den hier angezeigten IP-Adressen identisch sind.
NCache Managerservice
Wir werden das verwenden NCache Web Manager, um unseren Cluster-Cache zu erstellen und ihm Knoten hinzuzufügen. Um das aufzudecken NCache Web Manager werden wir eine weitere Kubernetes-Dienstressource bereitstellen. Hier ist die YAML-Datei für den Kubernetes-Dienst, die die verfügbar macht NCache Web Manager
Wie wir sehen können, lautet der „Name“ des Dienstes „ncache' und im Abschnitt „Ports“ sehen wir, dass der Port 80 dem Zielport 8251 zugeordnet wird, auf dem der NCache Web Manager wird zuhören. Wenn wir uns den Abschnitt „Selektor“ ansehen, sehen wir, dass der Dienst darüber ausgeführt wird NCache Server-Pods. Dieser Dienst wird im Backend der Ingress-Ressource registriert, die wir später bereitstellen werden, und von dort aus können wir über unseren Browser auf den Webmanager zugreifen.
Ich werde jetzt das erstellen NCache Dienstressource in meinem EKS-Cluster mithilfe der 'kubectl anwenden' Befehl. Nachdem der Dienst nun erstellt wurde, schauen wir uns die Beschreibung noch einmal an und wir sehen hier, dass die „Endpunkte“ die sind NCache Dienst auflöst, sind die IP-Adressen der NCache Servers
NCache Eintritt
Wir werden nun die Kubernetes-Ingress-Ressource bereitstellen, die das verfügbar macht NCache Web Manager über unseren Browser. Die Ingress-Ressource wird vom NGINX-Ingress-Controller implementiert. Der NCache Der Dienst, der im Backend des Ingress registriert wird, ermöglicht die Weiterleitung der HTTP-Anfragen, die über den Load Balancer eingehen, an den NCache Webmanager für NCache Verwaltungszwecken. Hier ist die YAML-Datei für die Ingress-Ressource, die wir im EKS-Cluster bereitstellen werden.
Der „Name“ des Ingress ist „ncache' und aus den Anmerkungen können wir ersehen, dass es mit dem NGINX-Ingress-Controller implementiert wird. Darüber hinaus zeigen diese Anmerkungen, dass wir Sticky Sessions mit dem verwenden werden NCache Webmanager. Um nicht zwischen den verschiedenen Web-Manager-Instanzen hin und her zu springen, die auf den verschiedenen ausgeführt werden NCache Servern und wir sind problemlos in der Lage, unseren Cluster-Cache zu erstellen und ihm innerhalb derselben Sitzung Knoten hinzuzufügen. Im Abschnitt „Regeln“ sehen wir, dass der Stammpfad der URL dem zugeordnet wird NCache Service, der das bloßstellt NCache Web-Manager.
Wir werden jetzt die Ingress-Ressource auf unserem EKS-Cluster erstellen. Nachdem der Ingress nun erstellt wurde, überprüfen wir seinen Status. Wir sehen jetzt, dass Ingress betriebsbereit ist. Lassen Sie uns die URL des Ingress überprüfen. Die URL wird im Abschnitt „Adresse“ angegeben. Wenn ich diese URL in meinen Browser kopiere, kann ich auf meinen Web Manager zugreifen. Also, ich rufe meinen Browser auf, klicke hier und füge die URL ein, und jetzt haben wir erfolgreich darauf zugegriffen NCache Web Manager aus dem Kubernetes-Cluster heraus.
Cache-Cluster erstellen
Wir werden jetzt unseren Cluster-Cache erstellen. Ich werde jetzt die Schritte zum Erstellen eines Cluster-Cache mit dem durchgehen NCache Webmanager. Klicken Sie also zunächst auf die hier gezeigte Schaltfläche „Neu“.
Jetzt geben wir dem Cluster-Cache einen Namen, „democache“, und klicken auf „Weiter“.
Wir werden die Partition der Replikattopologie im „Asynchronous“-Modus verwenden.
Und jetzt werde ich das hinzufügen NCache Server zum Cluster-Cache hinzufügen. Klicken Sie also auf die Schaltfläche „+“ und fügen Sie auch den anderen Server hinzu. Nachdem beide Server hinzugefügt wurden, klicken Sie auf „Weiter“.
Behalten Sie die Standardeinstellungen bei und klicken Sie am Ende auf „Fertig stellen“. Hier sehen wir nun im Hauptfenster, dass der „Democache“ erfolgreich erstellt wurde.
Um es zu starten, aktivieren Sie das Kontrollkästchen neben dem Namen des Caches und klicken Sie auf „Start“.
Der Cache wurde erfolgreich gestartet. Ich klicke jetzt auf die Registerkarte „Monitor“, um das zu öffnen NCache Überwachungstool.
Zunächst sehen wir im Abschnitt „Cluster Health“, dass der Cluster-Cache vollständig verbunden ist.
Wir sehen hier verschiedene serverseitige Leistungsindikatoren. Im Abschnitt „Anzahl“ sehen wir, dass das Konto 0 ist, da wir keine Clientanwendungen gestartet haben. Wenn Sie zum „Client-Dashboard“ gehen, können Sie dies überwachen NCache clientseitige Leistungsindikatoren.
Im „Report Dashboard“ erhalten Sie einen Gesamtüberblick sowohl über die serverseitigen als auch die clientseitigen Zähler.
Clientanwendungen bereitstellen und ausführen
Nachdem der Cluster-Cache erstellt wurde, führen wir nun unsere Client-Anwendungen aus. Hier ist die YAML-Datei, die zum Bereitstellen der Clientanwendungen im EKS-Cluster verwendet wird.
Wie aus der Bereitstellungsressource mit dem Namen „Client“ hervorgeht, verfügen wir über einen Pod, auf dem die Clientanwendungen ausgeführt werden. Hier wird das verwendete „Bild“ angezeigt, das beides enthält .NET Core und Java-Anwendungen sowie die NCache Client-Installation, damit wir die Client-Seite erfassen können NCache Leistungsindikatoren. Ich werde jetzt meine Clientressourcen im EKS-Cluster bereitstellen. Jetzt, da die Ressourcen erstellt wurden. Lassen Sie uns den Status des Client-Pods überprüfen. Das erste, was wir tun werden, ist, das zu starten .NET Core Anwendung. Im Client-Pod werde ich den folgenden Shell-Befehl ausführen: „/app/testerdotmet/run.sh Democache-Cacheserver“ Dafür sind zwei Parameter erforderlich, nämlich der Name des Caches, also „democache“, und der Name des Headless-Dienstes, der „cacheserver“.
Und wir sehen jetzt, dass die .NET Core Anwendung läuft. Komme rüber zum NCache Überwachen Sie, wir sehen im Abschnitt „Cluster-Gesundheit“, dass wir einen Kunden haben, und wir sehen eine Zunahme der Gegenaktivität. Die Zahl steigt, da die .NET Core Die Anwendung legt Daten in den Cache ab und im Abschnitt „Client-Prozess“ finden Sie hier die IP-Adresse des Pods, auf dem die Anwendung ausgeführt wird .NET Core die Anwendung ausgeführt wird, sowie die Prozess-ID der Anwendung. Wenn wir zum „Client-Dashboard“ kommen, sehen wir hier, dass wir clientseitige Zähler haben, die vom Client-Pod stammen.
Im „Report Dashboard“ erhalten wir einen Gesamtüberblick über diese server- und clientseitigen Leistungsindikatoren.
Nun, dass die .NET Core Nachdem die Anwendung ausgeführt wird, starten wir nun die Java-Anwendung. Genau wie bei der .NET Core Anwendung werde ich im Client-Pod den folgenden Shell-Befehl ausführen, der dieselben Parameter wie der verwendet .NET Core Anwendung, nämlich den Namen des Caches und den Namen des Headless-Dienstes.
Und wir sehen hier, dass die Java-Anwendung läuft. Zurück zum NCache Im Monitor sehen wir hier nun, dass es zwei Clients gibt, und wenn wir zum Abschnitt „Client-Prozess“ gehen, sehen wir einen weiteren Eintrag für den Client-Prozess, der mit der Java-Anwendung zusammenhängt. Damit konnten wir bestätigen, dass Anwendungen eine Verbindung mit dem herstellen können NCache Server, die auf demselben Kubernetes-Cluster ausgeführt werden.
Skalieren NCache Cluster
Wir werden jetzt unser Scale-Out durchführen NCache Cluster. Das erste, was ich tun werde, ist die Skalierung NCache Bereitstellung auf 3, sodass ich einen weiteren Server zum Cache-Cluster hinzufügen kann. Nachdem die Bereitstellung nun skaliert wurde, schauen wir uns die IP-Adressen der Server-Pods an. Hier sehen wir eine weitere NCache Server zum Kubernetes-Cluster hinzugefügt.
Und um den neuen Cache-Server hinzuzufügen, klicke ich auf den Link „Details anzeigen“ vor dem Namen des Caches.
Wenn ich zum Abschnitt „Serverknoten“ komme, klicke ich auf die Schaltfläche „Hinzufügen“ und gebe die IP-Adresse des dritten Servers ein.
Nachdem der Server nun hinzugefügt wurde, werde ich ihn starten und dazu das Kontrollkästchen neben der IP-Adresse aktivieren und auf „Start“ klicken.
Nachdem der Cache-Server nun gestartet ist, kehren wir zum Hauptfenster zurück. Hier sehen wir drei Server für den „Democache“.
Im Monitorfenster und im Abschnitt „Anzahl“ ist die Anzahl pro Knoten aufgrund der geltenden Lastausgleichsstrategie gesunken.
Wenn ich zum Hauptfenster zurückkomme, klicke ich auf die Schaltfläche mit den Auslassungspunkten neben dem Namen des Caches und wähle dann „Statistik anzeigen“ aus, damit ich eine andere Ansicht des Cache-Clusters erhalten kann. Hier sehen wir die aktive und die Replikatpartition, die für Zuverlässigkeit sorgen, indem die Daten auf einem Serverknoten gespeichert und von einem anderen Serverknoten innerhalb desselben Cache-Clusters gesichert werden.
Damit sind wir am Ende dieser Präsentation angelangt. Wenn Sie Fragen zur heute durchgeführten Demonstration haben oder mehr über die verschiedenen Funktionen erfahren möchten NCache bietet, zögern Sie bitte nicht, uns unter zu kontaktieren support@alachisoft.com. Danke.