WebLogic 14c: Kubernetes Operator

titelbild-kubernetes

Mit dem WebLogic Kubernetes Operator können WebLogic-Domänen auf einfache Weise in einem Kubernetes-Cluster betrieben werden. Er erweitert Kubernetes um die Möglichkeit, WebLogic-Instanzen erstellen, konfigurieren und verwalten zu können. In seiner Benutzung ist dieser nicht mehr von einem normalen Kubernetes-Befehl zu unterscheiden.

Vorbereitung

Um den Operator aufzusetzen, benötige ich eine Kubernetes-Umgebung mit dem Kubernetes-Paketmanager Helm. In diesem Beispiel arbeite ich mit Minikube als Kubernetes-Cluster. Als Container Engine wird Docker verwendet.

Zu Beginn muss ich mein Cluster starten. Bei Minikube wird dies mit dem folgenden Befehl gemacht. Damit die eigenen Container in Minikube verwendet werden können, müssen noch einige Umgebungsvariablen angepasst werden. Dies sorgt dafür, dass alle Images direkt in Minikube erstellt werden.

$ minikube start
$ eval $(minikube -p minikube docker-env) 

Sollte es noch kein Docker-Image für die gewünschte WebLogic-Version geben, sollte dieses jetzt mit dem Imagetool erstellt werden. Eine Anleitung dazu gibt es in einem früheren Artikel dieser Serie.

Um mit Helm Pakete installieren zu können, muss ich vorher die Paketquellen für den WebLogic Operator und den Loadbalancer hinzufügen. Der Loadbalancer sorgt in einer normalen Kubernetes-Umgebung dafür, dass Anfragen aus dem Internet an den gewünschten (virtuellen) Server im Cluster weitergeleitet wird. Ich benutze dafür Traefik.

$ helm repo add traefik https://containous.github.io/traefik-helm-chart/
$ helm repo add weblogic-operator https://oracle.github.io/weblogic-kubernetes-operator/charts
$ helm repo update 

Für meine Anwendung verwende ich die Vorlagen von Oracle. Dazu klone ich das folgende Git-Repository in das aktuelle Arbeitsverzeichnis.

$ git clone https://github.com/oracle/weblogic-kubernetes-operator.git 

Installation

Traefik

Als ersten Installationsschritt installiere ich den Loadbalancer Traefik. Um meine installierten Anwendungen besser betrachten zu können, erstelle ich für jede einen eigenen isolierten Namensbereich.

$ kubectl create namespace traefik
$ helm install traefik-operator traefik/traefik \
    --namespace traefik \
    --values weblogic-kubernetes-operator/kubernetes/samples/charts/traefik/values.yaml \
    --set "kubernetes.namespaces={traefik}" 

Der Parameter --values verweist auf die Beispielkonfiguration für Traefik. Der Parameter --set setzt die Namensräume, auf die Traefik achten soll.

WebLogic Kubernetes Operator

Nach Traefik installiere ich auch schon den WebLogic Kubernetes Operator. Auch diesen versehe ich mit einem eigenen Namensraum. Um später Änderungen im Cluster vornehmen zu können, muss ich dem Operator ein Servicekonto übergeben. Dieses erstelle ich in meinem gerade erstellten Namensraum.

$ kubectl create namespace sample-weblogic-operator-ns
$ kubectl create serviceaccount -n sample-weblogic-operator-ns sample-weblogic-operator-sa
$ helm install sample-weblogic-operator \
  	weblogic-kubernetes-operator/kubernetes/charts/weblogic-operator \
  	--namespace sample-weblogic-operator-ns \
  	--set serviceAccount=sample-weblogic-operator-sa \
  	--set image=oracle/weblogic-kubernetes-operator:3.1.0 \
  	--set "enableClusterRoleBinding=true" \
  	--set "domainNamespaces={sample-domain1-ns}" \
  	--wait 

Durch den Parameter --set image=... teile ich Helm mit, welches Docker-Image es für die Installation verwenden soll. Existiert dieses noch nicht auf dem System, versucht Helm das Image aus einem bekannten Repository herunterzuladen. Mit --set "enableClusterRoleBinding=true" aktiviere ich die Nutzerrollenkonfiguration von Kubernetes für diese Installation. Und mit --set "domainNamespaces={sample-domain1-ns}" konfiguriere ich den Operator, den Namensraum sample-domain1-ns zu verwalten. Der letzte Parameter --wait lässt Helm noch auf den vollständigen Abschluss der Installation warten, bevor der Befehl endet.

WebLogic Domäne

Nachdem diese Operatoren installiert sind, überprüfe ich deren Status mit folgenden Befehlen. Beide sollten die einzelnen Anwendungen zeigen, die ich installiert habe.

$ kubectl get pods -n traefik
$ kubectl get pods -n sample-weblogic-operator-ns 

Wenn beide Operatoren gestartet sind, kann ich auch schon die WebLogic-Domäne erstellen. Diese wird auch in ihren eigenen Namensraum installiert. Den neuen Namensraum muss ich dem Traefik-Operator bekannt machten, damit dieser Anfragen dorthin weiterleiten kann. Damit der WebLogic-Operator die erstellte Domäne verwalten kann, muss ich ihm die Administrator-Zugangsdaten für die Domäne hinterlegen. Das mache ich in einem Kubernetes Secret. Der WebLogic Operator erwartet, dass das Secret nach folgendem Muster -weblogic-credentials benannt ist.

$ kubectl create namespace sample-domain1-ns
$ helm upgrade traefik-operator traefik/traefik \
  	--namespace traefik \
  	--reuse-values \
  	--set "kubernetes.namespaces={traefik,sample-domain1-ns}"
$ kubectl -n sample-domain1-ns create secret generic sample-domain1-weblogic-credentials \
  	--from-literal=username=weblogic \
  	--from-literal=password=welcome1 

Der Parameter `--reuse-values` sorgt dafür, dass alle früheren Änderungen an der Traefik-Installation erhalten bleiben.

Um ein Docker-Image mit Domäne zu erstellen, wird wieder ein Beispielskript von Oracle verwendet. Dieses ersetzt automatisch einige Konfigurationsparameter der Domäne mit den Werten aus der Datei create-domain-inputs.yaml. Diese Datei habe ich vorher kopiert aus ./weblogic-kubernetes-operator/kubernetes/samples/scripts/create-weblogic-domain/domain-home-in-image/create-domain-inputs.yaml und den Tag meines eigenen Docker-Images eingetragen. Dieser Wert bestimmt, welches Image der WebLogic Operator zur Erstellung der Container benutzt. Mit dem folgenden Befehl erzeuge ich die neue Domäne.

$ weblogic-kubernetes-operator/kubernetes/samples/scripts/create-weblogic-domain/domain-home-in-image/create-domain.sh \
	-i $PWD/create-domain-inputs.yaml \
	-o $PWD/weblogic-domains \
	-u weblogic \
	-p welcome1 \
	-e 

Mit dem Parameter -i gebe ich den absoluten Pfad zur Eingabedatei an und mit dem Parameter -o den absoluten Pfad zum Ausgabeordner an. In diesem Ordner werden die generierten .yaml-Dateien gespeichert, mit denen die Domäne im Cluster ausgerollt werden kann. Durch die Parameter -u und -p übergebe ich jeweils den Nutzernamen und das Passwort für das Administratorkonto der Domäne. Der Schalter -e am Ende bewirkt, dass die erstellten .yaml-Dateien direkt angewendet werden und ich das nicht noch manuell machen muss.

Um die Konfiguration der erstellten Domäne anzuschauen, führe ich folgenden Befehl aus.

$ kubectl describe domain sample-domain1 -n sample-domain1-ns
 

Da die Erstellung und das Starten der Container etwas dauern kann, muss ich jetzt erst einmal warten. Nach einer Minute sollten aber alle Container verfügbar sein. Den Status meiner Container kann ich mit folgenden Befehlen überprüfen.

$ kubectl get pods -n sample-domain1-ns
$ kubectl get services -n sample-domain1-ns 

Als letzten Schritt muss ich noch ein domänenweites Ingress installieren. Dies ermöglicht in einer normalen Kubernetes-Umgebung den Zugriff von Außen auf die WebLogic Server. Es konfiguriert Traefik automatisch so, dass der Hostname sample-domain1.org auf diese Domäne weiterleitet. Da ich in diesem Beispiel Minikube als Kubernetes-Umgebung nutze, muss ich zuvor noch die Ingress-Erweiterung aktivieren.

$ minikube addons enable ingress
$ helm install sample-domain1-ingress \
      weblogic-kubernetes-operator/kubernetes/samples/charts/ingress-per-domain \
      --namespace sample-domain1-ns \
      --set wlsDomain.domainUID=sample-domain1 \
      --set traefik.hostname=sample-domain1.org 

Das Ingress installiere ich in den Namensraum der WebLogic-Domäne und teile ihm über --set wls.domainUID den Namen der Domäne mit. Mit --set traefik.hostname gebe ich noch an, über welche URL die Domäne erreichbar sein soll.

Nach der Installation des Ingress kann ich die Konfiguration mit folgendem Befehl ausgeben.

$ kubectl describe ingress -n sample-domain1-ns
 

Um durch Minikube auf das Cluster zugreifen zu können, muss ich noch einen Eintrag in der Hosts-Datei anlegen. Um jetzt über Minikube auf den Administrationsserver zugreifen zu können, muss ich diesen noch einmal extra bereitstellen lassen.

$ echo "$(minikube ip) sample-domain1.org" | sudo tee -a /etc/hosts
$ minikube service sample-domain1-admin-server-ext -n sample-domain1-ns 

Dieser Befehl sollte automatisch den Browser mit der passenden URL und dem passenden Port für den Administrationsserver öffnen.

Um den Aufbau des Kubernetes-Clusters besser verstehen zu können, habe ich diesen in folgendem Schaubild verdeutlicht.

Fazit

Ich habe in diesem Artikel gezeigt, wie ein WebLogic Kubernetes Operator mit Traefik als Loadbalancer installiert werden kann. Zum Schluss habe ich noch gezeigt, wie eine Domäne erstellt und ein passendes Ingress für die Domäne eingerichtet werden kann, um auf ihre Server zugreifen zu können.

By accepting you will be accessing a service provided by a third-party external to https://blog.ordix.de/