utilizzando NCache in Azure Kubernetes Service (AKS)

Cluster di Azure Kubernetes con contenitori Docker

Azure Kubernetes Service (AKS) è una piattaforma di applicazioni container open source di Microsoft basata sull'orchestratore di container Kubernetes per lo sviluppo e la distribuzione di applicazioni aziendali.

Se stai lavorando con .NET/.NET Core o Java in esecuzione in Azure Kubernetes e vuoi usarlo NCache per migliorarne le prestazioni e la scalabilità per i picchi di carico delle transazioni, ti assicuriamo che NCache supporta pienamente questo ambiente.

Guarda questo video per vedere com'è facile da distribuire NCache per il cluster Azure Kubernetes come distribuzione Docker.

AKS è un servizio contenitore gestito disponibile nel cloud pubblico di Microsoft Azure. È basato su contenitori di applicazioni che sono alimentati da Docker mentre i servizi di orchestrazione e gestione sono forniti da Kubernetes e oggi ti mostrerò i dettagli passo passo per la distribuzione e l'utilizzo di NCache in questa piattaforma. Iniziamo rapidamente con questo.

NCache Distribuzione in AKS

Prima di tutto, esaminiamo NCache Distribuzione in AKS.

Ecco una tipica distribuzione di NCache in AKS. Sto mostrando un singolo cluster Kubernetes con diverse distribuzioni di applicazioni e NCache Distribuzione cluster. Ho un'app Web Java che utilizza Docker Image su diversi pod. Ho anche un servizio Web Java, ancora una volta distribuito su pod diversi e queste applicazioni Java utilizzano il client Java di NCache per connettermi al mio cluster di cache.

Allo stesso modo, ho un ASP.NET Core App Web distribuita su diversi pod utilizzando Docker Image e queste, sai, queste istanze stanno utilizzando .NET Core installazione di NCache per connettere il mio cluster di cache. My Cache Cluster si basa anche su Docker Image, che è un'immagine basata su Linux di NCache, disponibile sul nostro sito Web e su Docker Hub ed è quello che ho usato per creare un cluster di cache su diversi pod.

Inoltre, ho questo NCache Gateway di monitoraggio remoto. Questo è un gateway per le operazioni di monitoraggio e gestione eseguite dall'esterno di questo cluster Kubernetes per gestire e monitorare il mio cluster di cache e ho questo servizio di rilevamento della cache. Questo è un servizio senza testa che ha anche un nome ed è lì che si connettono i miei client e che gestisce tutti i tipi di comunicazioni del server con il mio cluster di cache. Non ho bisogno di conoscere l'indirizzo IP dei pod 10, 11 e 12. L'applicazione client si connette solo a questo servizio di rilevamento e che a sua volta gestirà il rilevamento e l'instradamento di questi comandi o queste operazioni ai pod sottostanti.

Ti mostrerei i dettagli passo dopo passo su come creare effettivamente questo servizio di rilevamento e il gateway di monitoraggio remoto insieme al cluster di cache e alla distribuzione di queste applicazioni client, una volta che arriviamo alle nostre mani o parte. Ma per ora, questa è una distribuzione tipica di NCache in AKS usando un singolo cluster Kubernetes.

Configurazione dell'ambiente dimostrativo

Di seguito sono riportati i dettagli sulla configurazione dell'ambiente demo.

Sto usando 2 NCache Server per ospitare il mio cluster di cache e eseguirò 2 applicazioni client per connettermi a questa cache. Sto usando l'immagine Docker basata su Linux di NCache per questa distribuzione ed è rappresentato con questo tag "enterprise-server-linux-5.0.1" e questo tag deve far parte anche del tuo Docker Pull Command per poter utilizzare questa immagine. sto usando NCache Enterprise 5.0 Service Pack 1 e .NET Core rilascio di esso. Che puoi distribuire su Windows e su ambienti Linux, ma per la distribuzione in AKS sto usando l'immagine basata su Linux per questa versione. Sto usando l'applicazione Java che utilizzerà il client Java di NCache e poi sto usando 1 .NET Core Anche l'applicazione che sta utilizzando .NET Core Cliente di NCache. All'interno di queste applicazioni, utilizzerò CRUD Operations, che rappresenterebbe il caso d'uso di App Data Caching per le mie applicazioni.

Schierare NCache Server

Il primo passo è distribuire NCache Server in AKS. Quindi, iniziamo rapidamente con quello. Ok, ho effettuato l'accesso al portale di gestione di Azure ed è qui che inizierò con tutte le distribuzioni.

La prima cosa che devo fare è creare un gruppo di risorse e dopo andrei avanti e con tutte le distribuzioni, premi "Aggiungi" e inizierò effettivamente con questo passaggio.

Mantieni tutto semplice, "Revisiona + crea", premi "Crea" e questo andrebbe avanti e creerebbe un gruppo di risorse, in cui distribuirei il mio servizio Kubernetes. Quindi, se mi rinfresco su questo. Successivamente andremo avanti e creeremo il nostro servizio Kubernetes.

Se faccio clic su di esso, dovrei essere in grado di vedere tutte le distribuzioni all'interno di questo.

Al momento è vuoto e la prossima cosa è che dobbiamo creare "Kubernetes", giusto e ora posso creare il servizio Kubernetes.

A proposito, posso farlo anche tramite Azure Cloud Shell, che è proprio qui e "Riconnetti". Oppure posso usare il portale di gestione che è conveniente. Quindi, sceglierò il mio abbonamento e quindi il gruppo di risorse deve essere "aksdemo", quello che abbiamo creato di recente. Chiamerò il cluster Kubernetes "myaks" e, come puoi vedere, ha precompilato automaticamente anche il nome DNS. vado a scegliere '(US) Stati Uniti centrali' come la mia posizione. "Versione Kubernetes" deve essere specificato e andrò con l'impostazione predefinita, ma puoi scegliere quello che desideri e resto manterrei tutto semplice. Per "pool di nodi primari", è necessario specificare la "dimensione del nodo" e il "numero di nodi". Quindi, puoi scegliere lo standard o puoi cambiare la dimensione. È qui che verrà effettivamente ospitato il tuo servizio Kubernetes, giusto. Quindi, devi trovare la scelta giusta per il servizio con memoria, CPU e risorse di rete sufficienti.

Ti offre molte opzioni tra cui scegliere all'interno delle dimensioni della VM e quindi in base a diversi parametri come RAM, CPU, disco e altri parametri. Quindi, sceglierò "B2ms" perché è il minimo che posso usare per questo test e "Node count" sarà 2 per me, ma puoi trovare qualsiasi numero di nodi come 2 o 3 e questo è il numero di server con Kubernetes Cluster che verranno ospitati, giusto.

Quindi, dopo aver superato questo, sceglierò "Revisiona + crea" e ciò creerebbe il mio cluster Kubernetes.

Eseguirebbe una serie di convalide in Microsoft Azure, ma puoi vedere diverse impostazioni come "Scala", "Autenticazione", "Rete". Puoi mantenere tutto predefinito o modificare secondo necessità e puoi anche vedere il monitoraggio e se premi "Revisiona + crea", inizierebbe con il processo di convalida.

Quindi, dopo che la convalida finale è stata completata, premerò "Crea". Ci vorrebbero dai 5 ai 10 minuti per completarlo effettivamente in Microsoft Azure, ma dopo dovremmo essere in grado di iniziare con le distribuzioni. Come puoi vedere, la tua distribuzione è in corso, una volta fatto, questo trasformerebbe il segno di stato in verde, quindi, a questo punto devo mettere in pausa questo video e tornare una volta terminato. È già fatto, come puoi vedere.

La tua distribuzione è stata completata dopo aver impiegato da 5 a 10 minuti e ora posso andare su "Risorse" e in base a questo posso vedere il mio servizio AKS, che è "myaks", ecco fatto, creato con successo.

Se faccio clic su di esso, posso vedere tutti i dettagli di distribuzione per questo servizio, come la versione Kubernetes, l'indirizzo del server API e quindi il suo stato è riuscito e la posizione è quella che abbiamo specificato. Quindi, questo ha completato il nostro servizio Kubernetes.

NCache distribuzione lato server

Tornando al diagramma di distribuzione, il nostro servizio Azure Kubernetes è ora creato in Microsoft Azure, ma al momento è vuoto. Il prossimo passo è andare avanti NCache distribuzione lato server per distribuire il nostro cluster di cache. Quindi, vediamo come farlo.

Bene, il mio cluster AKS è ora configurato ed è disponibile per essere usato per le distribuzioni. Abbiamo usato il portale di gestione di Azure ma per il passaggio successivo, per tutte le distribuzioni, utilizzeremo Azure Cloud Shell e la prima cosa che dobbiamo fare è puntare verso il cluster AKS all'interno di questa shell. Quindi, per quello correrei 'az aks get-credentials' comando. Quindi, all'interno di 'az aks' è per il servizio Azure Kubernetes. Il comando "get-credentials" mi consente di portare il contesto corrente a "myaks" che è il nostro servizio AKS e all'interno di "aksdemo", questo è il nome del gruppo di risorse in cui viene creato. Quindi, ciò mi consentirebbe di puntare al servizio Azure Kubernetes "myaks" e posso iniziare con le operazioni di gestione e distribuzione.

Quindi, la prima cosa che dobbiamo esaminare è se sono presenti implementazioni esistenti? Quindi, andrei avanti ed eseguirei il comando molto velocemente, il che è 'kubectl ottieni i pod' e questo mi darebbe i Pod esistenti. Quindi, non ci sono risorse trovate nello spazio dei nomi predefinito, il che suggerisce che non ci sono ancora distribuzioni.

Ma dobbiamo schierarci NCache Server e per quello, porterei il NCache YAML ed è quello che userei per NCache Distribuzione lato server. Quindi, il tipo è scelto per essere "Distribuzione", il nome è ovviamente "ncache', quindi, questo è ciò a cui mi riferirò andando avanti per tutta la distribuzione lato server di NCache all'interno di altri servizi e anche all'interno delle Applicazioni client. L'immagine che stiamo usando è l'immagine Docker basata su Linux di NCache e sto usando due repliche. In sostanza, abbiamo due Pod, dove NCache Il cluster verrà distribuito all'inizio e quindi potremo aggiungere altri pod in una fase successiva. L'immagine Docker, parliamone un po' di più. L'immagine Docker che stiamo utilizzando è l'immagine Docker di Linux 5.0.1, disponibile sul nostro Alachisoft Pagina Docker Hub.

Abbiamo un comando 'docker pull' che per impostazione predefinita ti recherà un'immagine Windows, ma puoi anche usare Linux, usando questo tag proprio qui 'enterprise-server-linux-5.0.1' e questo ti porterebbe ed è quello che sto usando.

Quindi, andiamo avanti e aggiungiamo questo YAML per iniziare NCache Distribuzione lato server. Quindi, vado a correre 'kubectl create -f' e fornisci questo file YAML per iniziare NCache configurazione e caricamento del server NCache Immagine basata su Linux nel nostro cluster AKS. Ecco qua, NCache Viene creata la distribuzione. È così semplice.

Come parte della distribuzione, questo ha anche aperto alcune porte di gestione e monitoraggio, 8250 e 8251. Quindi, tutti i pod avrebbero queste porte aperte per la gestione e il monitoraggio e anche dall'esterno di questo cluster Kubernetes e quindi abbiamo anche il 'porta-client' che è la porta 9800 e che è la porta di comunicazione principale da client a server, che la nostra applicazione utilizzerebbe e si collegherebbe a questo cluster di cache. A questo punto il ns NCache La distribuzione lato server in EKS è stata completata.

Successivamente creeremo un gateway di rilevamento e gestione e poi torneremo a rivedere tutte queste distribuzioni contemporaneamente.

Servizio di rilevamento della cache

Ora che il nostro NCache I pod del server vengono distribuiti correttamente in AKS, il passaggio successivo consiste nel creare un servizio di individuazione della cache, nonché un gateway di gestione in AKS. Il servizio di rilevamento consentirebbe alle mie applicazioni client di rilevare, connettersi e utilizzare i pod sottostanti all'interno del cluster di cache che creeremo e quindi il nostro gateway di monitoraggio remoto consentirebbe a qualsiasi amministratore di sistema esterno a questo cluster di Kubernetes di gestire e monitorare questi pod per il cluster di cache .

Quindi, esaminiamo tutti i passaggi qui. Ora, per creare questi servizi, ho questo file "services.yaml" proprio qui che mi permetterebbe di creare questi servizi. Quindi, sto creando due servizi, un gateway e un servizio di rilevamento della cache. Il gateway è per il monitoraggio e la gestione, mentre il servizio di rilevamento è per la comunicazione client o server per, sai, il routing e il rilevamento ai pod sottostanti all'interno del cluster di cache.

Quindi, il primo servizio è il nostro servizio "gateway", proprio qui. Il tipo è scelto per essere "servizio" e sta mappando la porta 8251 sui Pod sottolineati e questo serve al mondo esterno per poter effettivamente connettersi ai Pod online per la gestione e il monitoraggio ed è per questo che ho scelto il tipo da 'LoadBalancer' e il selettore dell'app è 'ncache' e 'sessionAffinity' è un concetto molto importante. Dobbiamo sceglierlo come 'ClientIP'. Questo è un passaggio obbligatorio e ciò consente alle mie connessioni ai Pod sottostanti di essere appiccicose. Stiamo utilizzando uno strumento di gestione basato sul web, per gestire e monitorare NCache Baccelli. Ciò crea una sessione, quindi se la prima richiesta va al Pod uno, deve essere appiccicosa a quel Pod, quindi quella sessione rimane intatta anche per le chiamate successive. Quindi, è necessario che il bit "sessionAffinity" sia impostato su "ClientIP" per questo servizio gateway come must. Questo è un passaggio obbligatorio e quindi puoi iniziare con la distribuzione di questo.

Il secondo servizio è un servizio headless per il rilevamento automatico dei nodi del server cache per la comunicazione da client a server. Ho scelto il nome come "cacheserver". Di nuovo, il tipo di questo è "Servizio", quindi è di nuovo un servizio, senza testa e ciò che lo rende davvero senza testa è il "clusterIP", che viene scelto come "Nessuno". Quindi, non ha alcun IP. Gestisce semplicemente il rilevamento interno e l'instradamento delle applicazioni client con cui stabilire connessioni NCache Baccelli. E come si collega NCache Baccelli? Con l'aiuto del selettore che e'ncache' ed è quello per cui abbiamo usato NCache distribuzione anche quando abbiamo distribuito NCache Server Pods e in questo abbiamo essenzialmente la mappatura per, sai, per questo servizio di rilevamento abbiamo una mappatura di 8250 ai Pod sottostanti, una mappatura 8251 e quindi 9800 per la comunicazione client-server.

Quindi, andremo avanti e caricheremo questo file YAML, usando di nuovo lo stesso 'creare kubectl' comando con /f e distribuiremo questi due servizi nel nostro cluster AKS. Penso che ci sia un errore di battitura, 'aksconfigs/services.yaml'. Se premo invio su questo, dovrei essere in grado di vedere due servizi creati. Un servizio gateway e un server cache, che è un servizio di rilevamento automatico per NCache Pod del server.

Ora, se ve lo mostro velocemente 'kubectl ottieni i pod' comando, che me lo mostrerebbe, prima di tutto NCache Pod del server, perché si tratta di due Pod che avranno e riceveranno la distribuzione lato server. Puoi vedere che abbiamo NCache Pod con questi ID e abbiamo anche IPS assegnato a questi. Sono in esecuzione e il primo Pod è in esecuzione con 10.244.1.4 IP e poi abbiamo anche il secondo Pod con .0.9 IP.

Ti mostrerei anche il 'kubectl ottieni servizi' puoi semplicemente dire "svc" e ciò farebbe crollare tutti i servizi che abbiamo creato. Quindi, abbiamo "cacheserver", che è un servizio headless e poi abbiamo anche il "gateway", che ha anche un indirizzo IP che ci consente di monitorare e gestire effettivamente i nostri NCache Pod con l'aiuto della mappatura delle porte dal mondo esterno. Quindi, 8251, puoi vedere che è effettivamente aperto anche per questo e il Cache Server non mostra IP, che è essenzialmente un servizio senza testa per le applicazioni client per la connessione al Cache Cluster.

Quindi, usando questo IP esterno dovrei essere in grado di accedere alla console di gestione. Quindi, sto lanciando il nostro strumento di gestione basato sul Web utilizzando questo 8251, penso che ci sia, lascia che lo cambi, 8250, sì, ecco fatto. Quindi, ho effettuato l'accesso a questo strumento di gestione e sono infatti connesso al server 10.244.0.9 e questo garantisce che effettivamente i nostri servizi siano completamente funzionanti. Siamo in grado di monitorare e gestire effettivamente NCache, poiché siamo stati in grado di aprire lo strumento di gestione dalla mia macchina. Il passaggio successivo consiste nell'iniziare effettivamente con la creazione del cluster di cache. Quindi, lo esamineremo. A questo punto tutte le nostre implementazioni sono completate.

Crea cluster di cache

Ora possiamo andare avanti e creare il nostro NCache Cluster di cache successivo. Ora creerò un cluster di cache facendo clic su "Nuovo", che aprirebbe la cache tramite la procedura guidata di creazione.

Chiamerei semplicemente il mio cluster di cache "democache". Mantieni tutto predefinito qui. Il primo IP viene automaticamente suggerito e il secondo IP è qualcosa che posso scegliere da qui 1.4, riportarlo qui e quindi dovrei essere in grado di aggiungere anche questo e premere "Avanti" andrebbe avanti e mi darebbe alcuni parametri in più. Mantieni tutto predefinito e basta. Il mio cluster di cache è ora creato. Se faccio clic su "Visualizza dettagli", posso vedere che è completamente creato.

Quindi, andrò avanti e avvierò questo cluster di cache su entrambi i pod e ciò avvierà il mio cluster di cache e puoi vedere che il messaggio di stato ha visualizzato che il cluster è completamente funzionante e anche avviato.

Ora posso aprire lo strumento di monitoraggio che è di nuovo uno strumento di monitoraggio basato sul Web per NCache ciò mi consentirà di monitorare il mio servizio così come i clienti e mostra completamente connesso tra questi due Pod, questo è lo stato completamente connesso. Quindi, sono a posto per quanto riguarda la creazione di cluster. Una serie di parametri, nessuna applicazione client è connessa a questo punto, ma possiamo effettivamente eseguirli una volta che abbiamo distribuito ed eseguito l'applicazione client.

Distribuire ed eseguire applicazioni client

Il passaggio successivo consiste nel distribuire ed eseguire applicazioni client per connettersi al nostro cluster di cache in AKS. Ok, ora dobbiamo distribuire anche il client di distribuzione e per questo ho un altro container che distribuirò ed è un singolo container client che ha sia Java che.NET Core Applicazioni client in bundle in esso.

Quindi, andrò avanti e caricherò il file "client.yaml" e non appena verrà creata questa distribuzione avrei le mie due applicazioni che saranno pronte per essere utilizzate contro il mio cluster di cache. Per verificare se questi sono, sai, distribuiti correttamente, prima di tutto correrei 'kubectl ottieni i pod' comando e questo mi mostrerebbe che il contenitore è in fase di creazione, giusto. Quindi, lo stato attuale è e posso vedere un contenitore aggiuntivo, quindi è un buon inizio.

Quindi, la mia distribuzione lato client è in corso e se ricordi che abbiamo eseguito questo comando in precedenza anche il 'kubectl ottieni i pod' in precedenza avevamo solo NCache Distribuisce due Pod lì, ma ora abbiamo un Pod aggiuntivo in Client Deployment e ha il proprio set di parametri e alcuni IPS gli verrebbero assegnati. Quindi, se lo eseguo ancora una volta, è completamente funzionante e ha il proprio IP assegnato con questo ID specifico, proprio qui.

Ora per eseguire le applicazioni client per connettersi con questo cluster di cache, vorrei eseguire 'kubectl exec' fornire l'ID di questo Pod e quindi andrei nella directory proprio qui, app/tester e per prima cosa eseguirò il .NET Core Il cliente e io eseguiremmo lo script run.sh. Ciò mi permetterebbe di girare a .NET Core Applicazione che si collegherebbe alla mia cache. Ho inoltre bisogno del nome della cache, "democache" e quindi ho anche bisogno del servizio di rilevamento della cache che era "cacheserver". Ciò mi consentirebbe di scoprire e connettermi a tutti i Pod all'interno NCache Distribuzione e questa è una funzionalità all'interno NCache Client, che si connette automaticamente a tutti i Pod se si specifica solo questo servizio di discovery. Quindi, il mio "democache" è stato inizializzato.

Se torno allo strumento di monitoraggio, dovrei vedere alcuni parametri, alcune matrici di prestazioni. Un client è completamente connesso anche a .9 e .4 e abbiamo Richieste/secondo. Il microsecondo medio per operazione cache, aggiunte, recuperi e aggiornamenti, su tutti i contatori mostrano attività e ora viene visualizzato un processo client, che è 1.5 e questo è l'IP del nostro pod client, che è connesso a entrambi i server. 9 così come a .4. Quindi, questo mostra che il nostro contenitore dell'applicazione client e .NET Core L'applicazione è completamente in grado di connettersi al nostro cluster di cache.

Eseguiamo l'applicazione Java, per questo ho solo bisogno di cambiare "dotnet" in "java" ed eseguirlo. Quindi, ciò eseguirebbe semplicemente un altro script all'interno di quello e verrà eseguito 'NCacheTester.jar', quindi, questo è il file Java che si connetterà e inizierà a eseguire operazioni di creazione/lettura e aggiornamento/eliminazione. Quindi, le operazioni CRUD vengono eseguite al momento.

Quindi, se torno di nuovo al monitoraggio, ora ho due processi client. Ne vediamo quattro, perché ci sono due server. Quindi, ogni processo client effettua connessioni a tutti i server ma hai due client in esecuzione sul nostro cluster di cache e ci sono due pod nel cluster di cache.

Abbiamo alcuni "Dashboard report" più avanzati come la vista Report lato server che mi mostra i contatori lato server e le repliche da entrambi i pod e poi abbiamo anche il report client, che mostra anche i contatori lato client. Pertanto, all'interno di AKS siamo in grado di gestire e monitorare completamente le nostre distribuzioni client e server, senza problemi.

Ridimensionamento NCache Cluster

La prossima cosa che dimostrerò è ridimensionare il tuo NCache Cluster di cache nella piattaforma AKS. Questo ti aiuterà ad aumentare la tua capacità di gestione delle richieste per NCache e anche quello una volta. Vediamo tutti i passaggi coinvolti qui.

Ora, per scalare da 2 nodi a 3 nodi e anche questo in fase di esecuzione senza arrestare il cluster di cache in AKS o interrompere le applicazioni del tipo, possiamo semplicemente andare avanti e dimostrarlo. Quindi, prima di tutto ti mostrerei la distribuzione attuale. Vediamo i Pod attuali che abbiamo e se noti che abbiamo due Pod NCache Distribuzione .4 e .9 indirizzi IP e quindi avrei bisogno di eseguire questo comando qui, dove ho impostato il conteggio delle repliche su 3 e lo faccio per 'deployment/ncache' e questo dovrebbe far girare automaticamente un nuovo Pod e aggiungerlo a ncache/distribuzione. Penso che ci sia un errore di battitura, quindi lasciami eseguire semplicemente correggendolo la distribuzione e ha funzionato. Così, NCache la distribuzione è stata ridimensionata.

Ora abbiamo 3 Pod all'interno NCache Distribuzione. Quindi, se eseguo di nuovo lo stesso comando, ora dovrei vedere un Pod aggiuntivo all'interno NCache Distribuzione. Quindi, in precedenza, avevamo due distribuzioni per NCache .4 e .9 e ora abbiamo aggiunto un terzo Pod. Oltre a .4, .9 abbiamo anche .6. Quindi, questo è il nostro terzo Pod aggiunto, che ora è completamente funzionante.

Ho notato che non abbiamo interrotto l'applicazione o la cache stessa. Ora devo solo aggiungere questo Pod di cui essere Pod NCache Cluster di cache. Quindi, è stato distribuito in AKS.

Lo aggiungerei qui e poi andrei avanti e "Inizia" per unirmi al cluster di cache e questo verrà fatto in fase di esecuzione. Quindi, senza ritardi, si unirebbe al cluster di cache in esecuzione ed è anche completamente funzionante.

Se torno rapidamente allo strumento di monitoraggio, ora vedresti un terzo nodo unito in fase di esecuzione. Quindi, .6 è ora completamente unito. Ha tutti i dati. Puoi vedere il conteggio e quindi tutte le richieste sono completamente distribuite su 3 nodi anziché 2.

Puoi anche vedere lo stato del cluster, .6 è completamente connesso anche con 2 client ad esso collegati e ora abbiamo contatori che mostrano 3 server invece di 2 e i processi client sono di nuovo collegati a tutti e 3 i server a .6, .4 , anche a .9.

Conclusione

Quindi, ciò completa la parte di ridimensionamento automatico per AKS, in cui è possibile aggiungere Pod in fase di esecuzione e non è necessario arrestare la cache o nessuno dei client ad essa collegati. Tutto è fatto in fase di esecuzione.

Questo ci porta alla fine del nostro video. Abbiamo dimostrato con successo come puoi distribuire NCache nella piattaforma AKS e quanto sia facile da usare NCache dall'interno del tuo Java e .NET Core Applicazioni. Abbiamo anche esaminato l'efficacia con cui puoi gestire e monitorare il tuo NCache distribuzioni in AKS. Spero che questo sia stato utile.

Condividi il tuo feedback o le tue domande con noi all'indirizzo Alachisoft supporto support@alachisoft.com. Grazie!