WebLogic su Kubernetes? Provaci!

Il team WebLogic sta certificando i domini WebLogic orchestrati in Kubernetes. Come parte di questo lavoro, abbiamo creato un esempio che distribuisce un dominio / cluster WebLogic in un ambiente Kubernetes e ridimensiona / restringe il cluster attraverso Kubernetes e WebLogic.

WebLogic Server offre un ricco set di funzionalità per monitorare e diagnosticare server, applicazioni e risorse. In questo esempio, esponiamo queste metriche tramite Prometeo e le visualizziamo in Grafana. Abbiamo scritto un esportatore WebLogic, espone le metriche WebLogic in un formato che può essere compreso da Prometeo.

Questa configurazione di esempio dimostra l’orchestrazione di un cluster di dominio WebLogic 12.2.1.3 in un ambiente Kubernetes. L’esempio mostra diverse azioni di ridimensionamento del cluster WebLogic in Kubernetes:

  1. Ridimensionare / ridurre il cluster aumentando / diminuendo il numero di ReplicaSet.
  2. Definire un criterio WLDF basato su MBean di conteggio sessioni aperte e consentire a WLS Admin Server di avviare l’azione di ridimensionamento.

Usiamo StatefulSets per definire i server WebLogic nel dominio. Ciò fornisce un modo coerente di assegnare nomi di server gestiti e di fornire ai server gestiti in un cluster WebLogic una visibilità coerente reciproca attraverso nomi DNS noti.

Esistono 2 applicazioni distribuite nel cluster WebLogic; l’applicazione Open Session che attiva il criterio WLDF per ridimensionare il cluster di un server gestito e l’applicazione Memory Load alloca memoria heap nella JVM.

Quando viene attivato il criterio WLDF, viene effettuata una chiamata a un webhook in esecuzione in un contenitore nello stesso pod dell’Admin Server. Il webhook richiama un’API Kubernetes per attivare Kubernetes per ridimensionare il cluster Kubernetes e quindi ridimensionare il cluster WebLogic.

Come parte di questo esempio, abbiamo sviluppato un esportatore WLS che formatta le metriche Wean Runtime MBean raccolte dai server gestiti e le espone in un formato che può essere letto da Prometheus e visualizzato in un’interfaccia utente di Grafana.

Le istruzioni per eseguire questo esempio si basano sull’esecuzione in Minikube. Tuttavia, questo esempio verrà eseguito su qualsiasi ambiente Kubernetes. Assicurati di avere minikube, kubectl installato e di aver creato l’oracolo / weblogic di installazione dello sviluppatore di WebLogic: 12.2.1.3-developer. Trova il Dockerfile e gli script per creare questa immagine in GitHub.

Per creare l’immagine di dominio WebLogic 12.2.1.3 in questo esempio:

$ cd wls-12213-domain

$ docker build – build-arg ADMIN_PASS = – build-arg ADMIN_USER = -t dominio wls-12213.

Distribuiamo due webapp, l’applicazione Open Session e l’applicazione Memory Load, nel cluster WebLogic. Estendiamo l’immagine di dominio immagine di dominio wls-12213 e creiamo l’immagine di dominio demo wls-12213-oow:

$ docker build -t wls-12213-oow-demo-domain -f Dockerfile.adddemoapps.

Per creare l’immagine webhook (oow-demo-webhook image) che viene utilizzata per ridimensionare il cluster quando viene attivato il criterio WLDF, richiamare:

$ docker build -t oow-demo-webhook -f Dockerfile.webhook.

Salvare le immagini della finestra mobile webapp e webhook nel file system (* .tar) in modo da poterle poi caricare nel registro minikube:

$ docker save -o wls-12213-oow-demo-domain.tar wls-12213-oow-demo-domain

$ docker salva -o oow-demo-webhook.tar oow-demo-webhook

Avvia minikube e imposta l’ambiente:

$ minikube start

$ eval $ (minikube docker-env)

Carica le immagini della finestra mobile salvate webapp e webhook in minikube:

$ minikube ssh “docker load -i $ PWD / wls-12213-oow-demo-domain.tar”

$ minikube ssh “docker load -i $ PWD / oow-demo-webhook.tar”

Dalla directory OracleWebLogic / samples / wls-k8s, avviare WebLogic Admin Server e Managed Server:

$ kubectl create -f k8s / wls-admin-webhook.yml

$ kubectl create -f k8s / wls-stateful.yml

Verifica che le istanze siano in esecuzione:

$ kubectl get pods

Dovresti vedere un Admin Server e due Managed Server in esecuzione:

NOME STATO PRONTO RIAVVIA ETÀ

ms-0 1/1 In esecuzione 0 3m

ms-1 1/1 In esecuzione 0 1m

wls-admin-server-0 1/1 In esecuzione 0 5m

Verificare che tutti e tre i server abbiano raggiunto lo stato In esecuzione prima di continuare.

I server sono accessibili sull’indirizzo IP minikube, in genere 192.168.99.100. Per verificare quell’indirizzo:

$ minikube ip

192.168.99.100

Per accedere alla console di amministrazione, dal browser immettere http://192.168.99.100:30001/console. Accedi usando le credenziali passate come argomenti di build quando è stata creata l’immagine del dominio WLS (dominio wls-12213).

Avviare Prometheus per monitorare i server gestiti:

$ kubectl create -f prometheus / prometheus-kubernetes.yml

Verificare che Prometheus stia monitorando entrambi i server gestiti passando a http://192.168.99.100:32000. Fai clic sul menu a discesa delle metriche e seleziona “wls_scrape_cpu_seconds” e fai clic su “Esegui”. Dovresti vedere una metrica raccolta da ciascun Managed Server.

Avviare Grafana per monitorare i server gestiti:

$ kubectl create -f prometheus / grafana-kubernetes.yml

Connettiti a Grafana a: http://192.168.99.100:31000

Accedi con admin / pass

Fai clic su “Aggiungi origine dati” e quindi collega Grafana a Prometheus inserendo:

Nome: Prometeo

Tipo: Prometeo

Url: http: // prometheus: 9090

Accesso: proxy

Fai clic sul menu più a sinistra sulla barra dei menu e seleziona Dashboard> Importa.

Carica e importa il file prometheus / grafana-config.json e seleziona l’origine dati che hai aggiunto nel passaggio precedente (“Prometheus”). Dovrebbe generare una dashboard denominata “WLS_Prometheus”.

Vedrai tre grafici, il primo mostra “Managed Server Up Time”, il secondo mostra la webapp “Apri conteggio sessioni” e il terzo mostra “Dimensione corrente heap usata”.

Per eseguire la webapp “Memory Load”, nel browser invocare http://192.168.99.100:30011/memoryloadapp. Quando si fa clic sul pulsante “Esegui caricamento memoria”, verrà visualizzato un picco di memoria sul grafico Grafana etichettato “Dimensione corrente heap usata”.

Ridimensionare il cluster Kubernetes richiamando kubectl e aumentando il numero di repliche nel cluster

$ kubectl scale statefulset ms – repliche = 3

Il cluster Kubernetes dovrebbe mostrare un pod che esegue WLS Admin Server e webhook e tre pod ciascuno con un singolo server gestito. L’esecuzione di “kubectl get pods” mostra ms-0, ms-1, ms-2 e wls-admin-server-0.

L’Admin Console di WebLogic mostrerà anche che ms-0, ms-1, ms-2 sono in ESECUZIONE e ms-3 e ms-4 sono in ESCLUSIONE. Prometheus dovrebbe mostrare le metriche per tutti e tre i server gestiti in esecuzione e il grafico di Grafana “Tempo di server” dovrebbe visualizzare 3 righe, che rappresentano il server gestito

Ora ridimensioneremo il cluster Kubernetes in due repliche:

$ kubectl scale statefulset ms – repliche = 2

Puoi visualizzare la scala in basso con il comando “kubectl get pods” o tramite l’Admin Console

Nell’Admin Console abbiamo definito una regola WLDF per attivare un evento di ridimensionamento. Abbiamo definito una regola intelligente WLDF configurata per monitorare OpenSessionsCurrentCount di WebAppComponentRuntimeMBean per ApplicationRuntime chiamato “OpenSessionApp”. Un’azione REST viene attivata quando il numero medio di sessioni aperte> = 0,01 sul 5% o più dei server in un cluster WebLogic chiamato “DockerCluster”, calcolato negli ultimi dieci secondi, campionato ogni secondo. L’azione REST richiama un webhook che ridimensiona lo Statefulset denominato “ms” di uno. La regola WLDF è configurata con un allarme di 1 minuto, quindi non attiverà un’altra azione entro 1 minuto

Richiama la webapp Open Session accedendo al tuo browser http://192.168.99.100:30011/opensessionapp.

Entro un minuto o due, verrà creata una nuova istanza ms-1, che verrà visualizzata tramite Admin Console, comando kubectl o in Grafana.

Connettiti a Grafana per verificare le metriche raccolte per OpenSessionCount nel grafico “Conteggio corrente sessioni aperte”

Quando sei pronto per ripulire il tuo ambiente, chiudi i servizi. Richiamare i seguenti comandi:

$ kubectl delete -f prometheus / grafana-kubernetes.yml

$ kubectl delete -f prometheus / prometheus-kubernetes.yml

$ kubectl delete -f k8s / wls-stateful.yml

$ kubectl delete -f k8s / wls-admin-webhook.yml

Finalmente ferma minikube:

$ minikube stop

L’esempio sopra descritto mostra l’esecuzione di un dominio WebLogic in un ambiente Kubernetes. Il team di WebLogic sta lavorando per certificare il dominio / cluster WebLogic in esecuzione su Kubernetes. Come parte dello sforzo di certificazione, rilasceremo linee guida nelle aree di gestione del dominio / cluster WebLogic, delle applicazioni, degli aggiornamenti delle applicazioni, delle patch e degli ambienti WebLogic sicuri in Kubernetes. Guarda il blog sulle linee guida ” Best practice sulla sicurezza per server WebLogic in esecuzione in Docker e Kubernetes”.

Come parte dello sforzo di certificazione, il team WebLogic intende rilasciare un operatore Kubernetes WebLogic che estende l’API Kubernetes per creare, configurare e gestire le istanze dei server WebLogic in un dominio / cluster e applicazioni per conto di un utente Kubernetes. L’operatore è a conoscenza della configurazione di Kubernetes e si basa sulle risorse e sul controller di Kubernetes, ma include anche il dominio WebLogic e conoscenze specifiche dell’applicazione per automatizzare e gestire le distribuzioni WebLogic. Resta sintonizzato per i futuri annunci del rilascio di WebLogic Kubernetes Operator e le linee guida su come distribuire e costruire ambienti WebLogic in Kubernetes!

Dichiarazione Safe Harbor

Il precedente ha lo scopo di delineare la nostra direzione generale del prodotto. È destinato esclusivamente a scopo informativo e non può essere incorporato in alcun contratto. Non è un impegno fornire materiale, codice o funzionalità e non si deve fare affidamento sulle decisioni di acquisto. Lo sviluppo, il rilascio e i tempi di tutte le caratteristiche o funzionalità descritte per i prodotti Oracle rimangono a discrezione di Oracle.


Originariamente pubblicato da Monica Riccelli su blogs.oracle.com il 13 ottobre 2017.