utilizzando NCache nel servizio AWS Elastic Kubernetes (EKS)

Cluster Kubernetes elastico con contenitori Docker

AWS Elastic Kubernetes Service (EKS) è un servizio Kubernetes gestito da Amazon Web Services (AWS) che ti consente di configurare il tuo cluster Kubernetes insieme a tutte le patch e gli aggiornamenti più recenti all'infrastruttura sottostante che lo supporta.

Se stai lavorando con .NET/.NET Core o applicazioni Java in esecuzione in EKS e che si desidera utilizzare NCache per migliorare le prestazioni e la scalabilità durante i picchi di carico delle transazioni, allora stai tranquillo NCache supporta pienamente questo ambiente.

Guarda questo video per vedere com'è facile da distribuire NCache nel tuo cluster Amazon Elastic Kubernetes.

NCache Distribuzione in EKS

Nel cloud AWS abbiamo un classico sistema di bilanciamento del carico davanti a un controller di ingresso, che è in esecuzione all'interno del cluster Kubernetes. La risorsa Kubernetes Ingress implementata da questo controller di ingresso instrada le richieste HTTP provenienti dal sistema di bilanciamento del carico ai diversi servizi in esecuzione all'interno del cluster. Ora, in tali ambienti applicativi distribuiti, è necessario disporre anche di una soluzione di memorizzazione nella cache distribuita, che fornisca scalabilità, affidabilità e disponibilità elevata durante l'esecuzione di operazioni di lettura rapida ed è qui che NCache entra in gioco

NCache può essere distribuito nel tuo cluster EKS come NCache server in esecuzione in contenitori Linux e questi contenitori sono ospitati all'interno dei pod Kubernetes. Gli indirizzi IP di questi NCache i server sono risolti dal Servizio di rilevamento della cache, che è un servizio senza testa Kubernetes e gli indirizzi IP da lì vengono utilizzati dalle applicazioni client per creare handle di cache con cui possono connettersi al NCache cluster e iniziare a eseguire operazioni di gestione e CRUD.

I seguenti sono i parametri importanti della dimostrazione che condurremo oggi. Il NCache I server che verranno distribuiti nel cluster EKS utilizzeranno la seguente immagine Docker 'alachisoft/ncache' con un'etichetta di 'enterprise-server-linux-5.0.2'.

Per ottenere tutte le immagini che NCache fornisce, fammi venire al Alachisoft sito web. Seleziona il 'Scarica' scheda e quindi fare clic su 'NCache'. Questo ti porterà al NCache Centro Download. Scorrendo verso il basso fino alla sezione "Docker Hub", posso semplicemente fare clic sulla seconda voce dall'alto e questo mi indirizzerà al Hub Docker pagina di Alachisoft NCache. Qui puoi vedere tutte le immagini che NCache fornisce. Tornando ai parametri, l'immagine che verrà utilizzata ha il NCache Enterprise Edizione 5.0 SP2 con a .NET Core installazione. La cache in cluster che creeremo utilizzerà la partizione della topologia di replica. Le due applicazioni di test che verranno utilizzate sono le seguenti. Ne abbiamo uno .NET Core Applicazione e un'applicazione Java e, in entrambi i casi, mostreremo l'aspetto della memorizzazione nella cache dei dati dell'app NCache. Inizieremo con 2 NCache server e quindi aumentare quel numero a 3. Per dimostrarlo, possiamo apportare modifiche dinamiche nel file NCache stato del cluster senza influire sulle prestazioni del client.

Crea cluster EKS

Ora siamo pronti per iniziare la nostra dimostrazione. La prima cosa da fare ovviamente è configurare l'infrastruttura EKS su cui implementeremo il nostro NCache server e risorse client. Qui, sono sulla pagina introduttiva di AWS per il servizio EKS. Qui troverai tutte le informazioni necessarie per mettere in funzione il tuo primo cluster EKS. Le informazioni includono i prerequisiti come il ruolo IAM e le policy richieste.

Inoltre, entra nei dettagli sulla creazione di un VPC, su cui distribuirai il tuo cluster EKS.

Più in basso troverai informazioni sull'installazione e sull'utilizzo dell'AWS CLI e delle utility della riga di comando "kubectlc" per l'accesso e la gestione del cluster Kubernetes.

Sono incluse anche le informazioni sul gruppo di nodi gestito da Kubernetes, che fornirà i nodi di lavoro su cui distribuirai le tue risorse Kubernetes. Userò le informazioni fornite qui per creare un cluster EKS su un VPC con 2 sottoreti pubbliche e 2 private e una volta che il mio cluster EKS è attivo e funzionante, procederò con il resto della dimostrazione.

Utilizzando questi passaggi forniti nella pagina introduttiva, ho già creato i ruoli IAM e l'infrastruttura VPC per il mio cluster EKS. Ora, eseguirò questi passaggi per creare l'infrastruttura EKS.

Quindi, per questo, sono sulla mia console di gestione AWS e farò clic sul collegamento Elastic Kubernetes Service. Questo mi porterà alla pagina principale del servizio EKS. Sotto l'intestazione "Amazon EKS" nel riquadro di sinistra della pagina, farò clic sul collegamento "Cluster".

Al momento, non ho alcun cluster EKS. Per questo farò clic sul collegamento "crea cluster".

Qui darò i parametri di configurazione. Quindi, inizierò con il nome del cluster EKS che è "eks-ncache'. Selezionerò '1.14' per 'Versione Kubernetes'. Selezionerò anche il "ruolo IAM" e il "VPC". Selezionerò il gruppo di sicurezza e tutto il resto verrà mantenuto predefinito e darò un tag per il cluster EKS e una volta terminato tutto ciò, farò clic sul pulsante "crea".

Ora che il Cluster EKS è in fase di creazione, metterò in pausa il video, perché ci vorrà del tempo. Nella pagina del mio cluster EKS posso vedere che 'eks-ncache' è attivo'. Il secondo passaggio consiste nel creare il gruppo di nodi di gestione e per questo scorrerò fino alla sezione "Gruppi di nodi" e farò clic sul pulsante "Aggiungi gruppo di nodi".

Darò i parametri iniziando con il nome del gruppo di nodi e selezionerò il "ruolo IAM".

Seleziono la "coppia di chiavi SSH", fai clic su "Avanti".

Qui userò il seguente 'Tipo AMI' e per il 'Tipo di istanza' userò 't3.small'. Dopo questo farò clic su "Avanti".

Seleziono 2 nodi di lavoro, fai clic su "Avanti".

E qui dopo aver esaminato i parametri, farò clic su "Crea" per iniziare la creazione del mio gruppo di nodi. Qui vediamo che il gruppo di nodi è nello stato di creazione in questo momento, quindi metterò in pausa il video. Vediamo qui ora che il mio gruppo di nodi EKS è "Attivo" e la creazione della mia infrastruttura EKS è completa.

Nel terminale PowerShell della mia macchina client, utilizzerò l'AWS CLI, per creare il mio file 'kubeconfig', per ottenere l'accesso al cluster EKS ed è stato creato il file 'kubeconfig'. Ora confermerò la mia connessione al cluster EKS e vedremo i due nodi di lavoro inclusi nel gruppo di nodi gestito da EKS.

Distribuire il controller di ingresso

La prima cosa che farò è distribuire le risorse Kubernetes necessarie per Ingress Controller. Passando al diagramma dell'architettura, il controller di ingresso mostrato qui verrà utilizzato per implementare la risorsa di ingresso che verrà distribuita in seguito.

Nella nostra dimostrazione, stiamo usando il controller NGINX Ingress a causa della sua popolarità. Prima di tutto, distribuiremo le risorse obbligatorie necessarie per far funzionare il controller di ingresso NGINX in qualsiasi ambiente Kubernetes e successivamente distribuiremo le risorse specifiche di AWS, che attiveranno un classico sistema di bilanciamento del carico davanti a NGINX Ingress Controller e consenti al controller di ingresso NGINX di ricevere richieste HTTP dall'esterno del cluster Kubernetes tramite questo classico sistema di bilanciamento del carico.

Ora distribuirò le risorse obbligatorie richieste per il controller di ingresso NGINX. Le definizioni di tali risorse possono essere trovate seguendo l'URL fornito nella sezione evidenziata. Quindi, senza ulteriori dettagli, iniziamo e le risorse obbligatorie sono state distribuite. Qui ho il file YAML aperto, che userò per distribuire due risorse relative al controller NGINX Ingress.

La prima risorsa è il servizio di bilanciamento del carico che verrà utilizzato per avviare un sistema di bilanciamento del carico classico davanti al controller di ingresso NGINX. Come possiamo vedere dalla sezione delle annotazioni, il sistema di bilanciamento del carico funzionerà a livello 7 instradando le richieste HTTP al controller di ingresso NGINX. L'altra risorsa che verrà distribuita è la risorsa "ConfigMap", che contiene i parametri di configurazione per il comportamento del controller di ingresso NGINX all'interno del cluster Kubernetes.

Ora distribuirò quelle risorse usando il 'applicazione kubectl' comando e le risorse sono state distribuite. Consentimi di accedere al mio dashboard EC2 e confermare che il sistema di bilanciamento del carico è stato avviato. Se aggiorno questa pagina, vedrai introdotto un nuovo sistema di bilanciamento del carico. Fammi fare clic sul link "bilanciatori di carico" ed ecco il bilanciatore di carico davanti al controller di ingresso NGINX.

Schierare NCache Server

Ora distribuiremo NCache Server al cluster EKS. Tornando di nuovo al diagramma dell'architettura, questi NCache i server vengono utilizzati per creare la cache in cluster all'interno del cluster EKS. Ecco il file YAML per la distribuzione di NCache server al cluster Kubernetes. Come possiamo vedere, questa è una risorsa di distribuzione che aumenterà NCache server all'interno del cluster EKS. Le seguenti sono le porte su cui il NCache i server saranno in ascolto. Abbiamo la porta 'management-tcp' con un valore di 8250, su cui il file NCache i server ascolteranno le richieste di connessione del client. Abbiamo la porta 'management-http' con un valore di 8251 su cui il file NCache gestore web ascolterà e poi avremo il 'client-port' con un valore di 9800, su cui il NCache i server ascolteranno le richieste di operazioni CRUD del client.

Usando il 'applicazione kubectl' comando, ora creerò il file NCache pod del server sul mio cluster EKS e ora controlliamo lo stato dei pod. I Pod sono in esecuzione. Abbiamo 2 NCache Server con gli indirizzi IP mostrati qui.

NCache Servizio di scoperta

Ora implementeremo il NCache Servizio di scoperta. Il servizio di rilevamento della cache è un servizio headless in esecuzione su NCache Pod del server. La sua funzione è quella di risolvere gli indirizzi IP che verranno utilizzati dalle applicazioni client, quando vogliono connettersi con la cache del cluster.

Ecco il file YAML per il servizio senza testa Kubernetes. Come possiamo vedere, il nome del servizio sarà 'cacheserver'. Osservando le sezioni "selettore" e "porte", vediamo che questo servizio verrà eseguito in aggiunta al NCache Pod del server.

Ora creerò la risorsa del servizio di individuazione della cache nel mio cluster EKS usando il file 'applicazione kubectl' comando. Ora che il servizio è stato creato, diamo un'occhiata alla descrizione di esso. Possiamo vedere che gli 'Endpoint' che il servizio risolve contengono gli indirizzi IP del NCache server, con gli indirizzi IP mostrati nella sezione evidenziata, che corrispondono agli indirizzi IP mostrati qui.

NCache Servizio Manager

Utilizzeremo il NCache Web Manager, per creare la nostra cache in cluster e aggiungervi nodi. Per esporre il NCache Web Manager implementeremo un'altra risorsa del servizio Kubernetes. Ecco il file YAML per il servizio Kubernetes, che esporrà il file NCache gestore web

Come possiamo vedere il 'nome' del servizio sarà 'ncache' e dalla sezione 'porti', vediamo che la porta di 80 verrà mappata alla porta di destinazione di 8251, su cui il NCache Web Manager sarà in ascolto. Osservando la sezione 'selettore', vediamo che il servizio verrà eseguito sopra il NCache Pod del server. Questo servizio verrà registrato sul back-end della risorsa Ingress che distribuiremo in seguito e da lì potremo accedere al web manager dal nostro browser.

Ora creerò il NCache risorsa di servizio nel mio cluster EKS usando il file 'applicazione kubectl' comando. Ora che il servizio è stato creato esaminiamo nuovamente la descrizione e vediamo qui che gli 'Endpoint' che il NCache il servizio risolve, sono gli indirizzi IP del NCache server.

NCache Ingresso

Ora distribuiremo la risorsa Kubernetes Ingress che esporrà il file NCache Web Manager dal nostro browser. La risorsa Ingress verrà implementata dal controller NGINX Ingress. Il NCache servizio che verrà registrato sul back-end di Ingress, consentirà di instradare le richieste HTTP in arrivo attraverso il sistema di bilanciamento del carico al NCache Web Manager per NCache finalità gestionali. Ecco il file YAML per la risorsa Ingress che verrà distribuita nel cluster EKS.

Il 'nome' dell'Ingress è 'ncache' e dalle annotazioni, possiamo vedere che verrà implementato con il controller NGINX Ingress. Inoltre, queste annotazioni mostrano che utilizzeremo sessioni permanenti con il NCache Gestore web. In modo da non rimbalzare sulle diverse istanze di web manager in esecuzione sulle diverse NCache server e siamo facilmente in grado di creare la nostra cache in cluster e aggiungere nodi ad essa all'interno della stessa sessione. Dalla sezione delle regole, vediamo che il percorso principale dell'URL verrà mappato su NCache servizio, che espone il NCache Gestore web.

Ora creeremo la risorsa Ingress sul nostro cluster EKS. Ora che l'Ingress è stato creato controlliamo lo stato di esso. Ora vediamo che Ingress è attivo e funzionante. Controlliamo l'URL di Ingress. L'URL è fornito nella sezione "Indirizzo". Se copio questo URL sul mio browser, potrò accedere al mio Web Manager. Quindi, venendo al mio browser, facendo clic qui e incollando l'URL e ora abbiamo eseguito correttamente l'accesso al file NCache Web Manager dall'interno del cluster Kubernetes.

Crea cluster di cache

Ora creeremo la nostra cache in cluster. Ora eseguirò i passaggi per creare una cache in cluster utilizzando il file NCache Gestore web. Quindi, per cominciare, fai clic sul pulsante "Nuovo" mostrato qui.

Ora assegneremo alla cache cluster un nome, "democache", fare clic su "Avanti".

Utilizzeremo la partizione della topologia di replica, in modalità "asincrona".

E ora aggiungo il NCache server nella cache del cluster. Quindi, facendo clic sul pulsante "+" e aggiungendo anche l'altro server. Con entrambi i server aggiunti, fai clic su "Avanti".

Mantieni tutto predefinito e alla fine fai clic su "Fine". Vediamo ora qui nella finestra principale che la 'democache' è stata creata con successo.

Per avviarlo, spunta la casella di controllo accanto al nome della cache e premi 'Avvia'.

La cache è stata avviata correttamente. Ora farò clic sulla scheda "Monitoraggio" per aprire il file NCache strumento di monitoraggio.

Innanzitutto, dalla sezione "Cluster Health", vediamo che la cache in cluster è completamente connessa.

Qui vediamo diversi contatori delle prestazioni lato server. Nella sezione "Conteggio", vediamo che l'account è 0, perché non abbiamo avviato alcuna applicazione client. Passando al "Client Dashboard", qui potrai monitorare il NCache contatori delle prestazioni lato client.

Nel "Report Dashboard", si ottiene una visione d'insieme dei contatori lato server e lato client.

Distribuisci ed esegui applicazioni client

Con la cache in cluster creata, ora eseguiremo le nostre applicazioni client. Ecco il file YAML, che verrà utilizzato per distribuire le applicazioni client nel cluster EKS.

Come si può vedere dalla risorsa di distribuzione, che ha il nome di client, avremo un Pod, su cui verranno eseguite le applicazioni client. L '"immagine" utilizzata è mostrata qui, questa contiene entrambi i .NET Core e applicazioni Java, nonché il NCache installazione del client, in modo da poter raccogliere il lato client NCache contatori di prestazioni. Ora distribuirò le mie risorse client nel cluster EKS. Ora che le risorse sono state create. Verifichiamo lo stato del Client Pod. La prima cosa che faremo è avviare il .NET Core Applicazione. All'interno del Client Pod, eseguirò il seguente comando Shell, "/app/testerdotmet/run.sh server cache democache" che accetta due parametri, vale a dire il nome della cache, che è 'democache' e il nome del servizio headless, che è 'cacheserver'.

E vediamo ora che il .NET Core l'applicazione è in esecuzione. Venendo al NCache Monitor, vediamo nella sezione "Salute del cluster" che abbiamo 1 client e vediamo un assorbimento dell'attività di contatore. Il conteggio è in aumento, dal momento che il .NET Core l'applicazione sta scaricando i dati nella cache e nella sezione "Processo client" ecco l'IP del Pod su cui il .NET Core l'applicazione è in esecuzione, nonché l'ID processo dell'applicazione. Venendo al "Client Dashboard", vediamo qui che abbiamo contatori lato client, provenienti dal client Pod.

Nel "Dashboard dei report", otteniamo una visione generale di questi contatori delle prestazioni lato server e client.

Ora che il .NET Core l'applicazione è in esecuzione, ora avvieremo l'applicazione Java. Proprio come con il .NET Core applicazione, all'interno del client Pod, eseguirò il seguente comando di shell, che accetta gli stessi parametri di .NET Core applicazione, ovvero il nome della cache e il nome del servizio headless.

E vediamo qui che l'applicazione Java è in esecuzione. Tornando al NCache monitor, vediamo qui ora che ci sono 2 client e scendendo alla sezione 'Processo client', vediamo un'altra voce per il processo client, che è correlata all'applicazione Java. Quindi, con questo siamo stati in grado di confermare che le applicazioni possono connettersi con il NCache server in esecuzione sullo stesso cluster Kubernetes.

Ridimensionamento NCache Cluster

Ora andremo a scalare verso l'esterno il nostro NCache Grappolo. La prima cosa che farò è ridimensionare il NCache distribuzione a 3, in modo da avere un altro server da aggiungere al cluster di cache. Ora che la distribuzione è stata ridimensionata, diamo un'occhiata agli indirizzi IP del pod del server e qui ne vediamo un altro NCache server aggiunto al cluster Kubernetes.

E per aggiungere il nuovo server cache, farò clic sul collegamento "Visualizza dettagli", davanti al nome della cache.

Scendendo alla sezione "Nodi del server", farò clic sul pulsante "Aggiungi" e fornirò l'indirizzo IP del terzo server.

Ora che il server è stato aggiunto, lo avvierò e per questo selezionerò la casella di controllo accanto all'indirizzo IP e farò clic su "Avvia".

Ora che il server cache è avviato, torniamo alla finestra principale e qui vediamo 3 server per la 'democache'.

Venendo alla finestra di monitoraggio e nella sezione "Conteggio", il conteggio per nodo è diminuito a causa della strategia di bilanciamento del carico in vigore.

Tornando alla finestra principale, farò clic sul pulsante con i puntini di sospensione accanto al nome della cache e quindi selezionerò "Mostra statistiche", in modo da poter ottenere un'altra vista del cluster di cache. Qui vediamo le partizioni attive e di replica, che forniscono affidabilità, avendo i dati in 1 nodo del server, eseguito il backup da un altro nodo del server, all'interno dello stesso cluster di cache.

Questo ci porta alla fine di questa presentazione. Se hai domande sulla dimostrazione che è stata eseguita oggi o vuoi saperne di più sulle diverse funzionalità che NCache fornisce, non esitate a contattarci all'indirizzo support@alachisoft.com. Grazie.