The java-devel and iproute-tc packages are required dependencies for Converged Application Server. The git package is required to clone the Kubernetes WebLogic Operator.

1. Install the required dependencies.

   sudo yum install java-devel git iproute-tc

2. Set the JAVA_HOME variable.
   For example:

   export JAVA_HOME=/etc/alternatives/jre

   Append this line to your ~/.bashrc file.

Docker is a popular container platform that allows you to create and distribute applications across your Oracle Linux servers. The Converged Application Server containers published on the Oracle Container Registry require Docker in order to pull and manage.

1. On your Oracle Linux 7 machine, enable the ol7_addons repository if it is disabled.

   sudo yum-config-manager --enable ol7_addons

2. Install Docker.

   sudo yum install docker-engine

3. Start the docker service.

   sudo systemctl enable --now docker

4. Add your user account to the docker group.

   sudo usermod -a -G docker $USER

5. Log out and log back in again.
6. Confirm your user account was added to the docker group.

   [myuser@ol7 ~]$ groups
   myuser wheel docker

   Note:

   If your user is not in the docker group, confirm the docker group exists with the command grep docker /etc/group. If that command returns no output, the docker group was not created when you installed docker-engine. Manually create the group with the command sudo groupadd docker and add your user again.
7. (Optional) If you are behind a proxy, follow these steps to set up the http_proxy and https_proxy variables for your docker client.

Before deploying Converged Application Server, you must log in to the Oracle Container Registry and accept the Java License Agreement for the JDK and the Middleware License Agreement for Converged Application Server.

1. Navigate to the Oracle Container Registry.
2. In the top-right corner, click Sign In.
3. Enter your Oracle credentials and click Submit.
4. Click Middleware and then click occas.
5. Select your language and click Continue.
6. Scroll to the end of the License Agreement and click Accept.
7. From the server where you installed Docker, log in to the Oracle Container Registry.

   docker login container-registry.oracle.com

   Note:

   If you are behind a proxy, follow these steps to set up the http_proxy and https_proxy variables for your docker client.
8. Create an account on https://hub.docker.com and use your credentials to login to Docker's repository with the docker login command..

   [myuser@ol7 ~]$ docker login
   Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to https://hub.docker.com to create one.
   Username: <enter your username>
   Password: <enter your password>

   Creating an account and logging in circumvents the limit that Docker places on anonymous downloads.

In addition to downloading the occas_generic.jar file, you need to download the Docker image files and scripts.

1. Sign in to My Oracle Support.
2. Download the occas8.zip file.
   1. Search for "Docker Script for OCCAS 8 Installation".
   2. Select Doc ID 2823095.1.
   3. Click the link under the Details section to download occas8.zip.
3. Unzip the file.

   unzip occas8.zip

   This creates the occas8/ directory.

The Converged Application Server docker image is located on the Oracle Container Registry.

1. If using JDK 8, pull the JDK 8 OCCAS container.

   docker pull container-registry.oracle.com/middleware/occas:8.0.0.0.0-generic-8

2. If using JDK 11, pull the JDK 11 OCCAS container.

   docker pull container-registry.oracle.com/middleware/occas:8.0.0.0.0-generic-11

1. After Kubernetes is installed, run kubeadm init to start Kubernetes.
2. Follow the instructions returned by the kubeadm command.

   mkdir -p $HOME/.kube
   sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
   sudo chown $(id -u):$(id -g) $HOME/.kube/config

3. Deploy a Pod network to the cluster.
   Converged Application Server supports Calico as the Pod network.

The WebLogic Kubernetes Operator supports running your WebLogic Server domains on Kubernetes, an industry standard, cloud neutral deployment platform. It lets you encapsulate your entire WebLogic Server installation and layered applications into a portable set of cloud neutral images and simple resource description files. You can run them on any on-premises or public cloud that supports Kubernetes where you’ve deployed the operator.

1. Install Helm, a package manager for Kubernetes.
   1. Download Helm.

      curl -O https://get.helm.sh/helm-v3.6.3-linux-amd64.tar.gz

      See the Releases page for other Linux architectures.

   2. Extract Helm.

      tar xf helm-v3.6.3-linux-amd64.tar.gz

   3. Move the Helm binary into your PATH.

      sudo install linux-amd64/helm /usr/local/bin/helm

2. Install the Oracle Weblogic Kubernetes Operator.
   The Oracle Weblogic Kubernetes Operator is used to configure the lifecycle of the Converged Application Server images. See the Oracle Weblogic Kubernetes Operator documentation.
   1. Clone the Weblogic Kubernetes Operator git repository.

      You can install any version higher than 3.2.0.

      git clone --branch v3.2.3 https://github.com/oracle/weblogic-kubernetes-operator

   2. Navigate to the weblogic-kubernetes-operator directory.

      cd weblogic-kubernetes-operator

      Note:

      Subsequent commands will assume your current directory is weblogic-kubernetes-operator.
3. Pull the Docker image for the WebLogic Kubernetes Operator and copy that image to all the nodes in your cluster.

   docker pull ghcr.io/oracle/weblogic-kubernetes-operator:3.3.2

4. Create the namespace for the Weblogic Kubernetes Operator.

   The syntax for the command is: kubectl create namespace <unique name>. For example:

   kubectl create namespace sample-weblogic-operator-ns

5. Create the service account within that namespace for the WebLogic Kubernetes Operator.

   kubectl create serviceaccount -n sample-weblogic-operator-ns sample-weblogic-operator-sa

6. Update the following parameters in the file weblogic-kubernetes-operator/kubernetes/charts/weblogic-operator/values.yaml.

   If you plan on installing the EFK stack, set elkIntegrationEnabled to true; otherwise, leave elkIntegrationEnabled as false.

   • serviceAccount—Set this to the previously created service account for the WebLogic Kubernetes Operator.

     serviceAccount: "sample-weblogic-operator-sa"

   • domainNamespaces—Set this to the previously created namespace for the WebLogic Kubernetes Operator.

     domainNamespaces:
     - "sample-weblogic-operator-ns"

   • elkIntegrationEnabled—Set this to true if you plan on installing the EFK stack; leave as false if you do not plan on installing the EFK stack.

     elkIntegrationEnabled: true

   • elasticSearchHost—Change the word 'default' in 'elasticsearch.default.svc.cluster.local' to the namespace previously created for the WebLogic Kubernetes Operator.

     elasticSearchHost: "elasticsearch.sample-weblogic-operator-ns.svc.cluster.local"

7. Paste the following role-based access control (RBAC) definition into a YAML file called rbac.yaml.

   See Using RBAC Authorization.

   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: helm-user-cluster-admin-role
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: cluster-admin
   subjects:
   - kind: ServiceAccount
     name: default
     namespace: kube-system

8. Apply the RBAC file.

   kubectl apply -f rbac.yaml

9. From the weblogic-kubernetes-operator directory, start the operator.

   helm install sample-weblogic-operator kubernetes/charts/weblogic-operator \
     --namespace sample-weblogic-operator-ns \
     --set image=ghcr.io/oracle/weblogic-kubernetes-operator:3.3.2 \
     --set serviceAccount=sample-weblogic-operator-sa \
     --set "enableClusterRoleBinding=true"\
     --set "domainNamespaceSelectionStrategy=LabelSelector"\
     --set "domainNamespaceLabelSelector=weblogic-operator\=enabled"\
     --wait

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

[weblogic-kubernetes-operator]$ kubectl get pods -n sample-weblogic-operator-ns
NAME                                 READY   STATUS    RESTARTS   AGE
weblogic-operator-7885684685-4jz5l   2/2     Running   0          2m32s
[weblogic-kubernetes-operator]$

Converged Application Server uses a Persistent Volume (PV) to store logs that can be viewed with Kibana. The PV may be either a local path on the master node or a NFS location.

1. Create and label a namespace that can host one or more domains.

   kubectl create namespace sample-domain1-ns
   kubectl label ns sample-domain1-ns weblogic-operator=enabled

2. On the server where you'll store the log files, create the PV directory with open permissions.

   mkdir /u01/pv
   chmod 777 /u01/pv

   Note:

   See Persistent Storage for details about permissions.
3. On the master node, navigate to the occas8/dockerfiles/8.0.0.0.0/occas-domain-home-on-pv directory.
4. Open the sample-domain1-weblogic-sample-pv.yaml file.
5. Set the storage parameter to the number of gigabytes to allocate to the persistent volume.
   storage: 50Gi
6. Update the hostPath parameter.
   • If using a local PV, set the path parameter to the local path.

       hostPath:
         path: "/u01/pv"

   • If using a remote PV, uncomment the nfs parameter and set the server and path parameters to the NFS server where the PV is located.

       nfs:
         server: 10.0.0.1
         path: "/mnt/share/pv"

7. Use the kubectl create command to create the persistent volume and the persistent volume claim.

   kubectl create -f sample-domain1-weblogic-sample-pv.yaml

   kubectl create -f sample-domain1-weblogic-sample-pvc.yaml

8. Use the kubectl get command to verify the persistent volume and persistent volume claim was created.

   [doc@docker:occas-persistant-volume]$ kubectl get pv -n sample-domain1-ns
   NAME                                CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                                                  STORAGECLASS                                   REASON   AGE
   sample-domain1-weblogic-sample-pv   50Gi       RWX            Retain           Bound    sample-domain1-ns/sample-domain1-weblogic-sample-pvc   sample-domain1-weblogic-sample-storage-class            23m
   [doc@docker:occas-persistant-volume]$ kubectl get pvc -n sample-domain1-ns
   NAME                                 STATUS   VOLUME                              CAPACITY   ACCESS MODES   STORAGECLASS                                   AGE
   sample-domain1-weblogic-sample-pvc   Bound    sample-domain1-weblogic-sample-pv   50Gi       RWX            sample-domain1-weblogic-sample-storage-class   8m11s
   [doc@docker:occas-persistant-volume]$

An Converged Application Server replicated domain is a logically related group of resources. Domains include the administration server and all managed servers. Converged Application Server domains extend Oracle WebLogic Server domains to support SIP and other telecommunication protocols.

1. Navigate to the occas8/dockerfiles/8.0.0.0.0/occas-domain-home-on-pv directory.
2. Run the create-weblogic-credentials.sh script to create the Secret for Weblogic.

   Kubernetes Secrets contain sensitive information like passwords. See Secrets.

   ./create-weblogic-credentials.sh -u weblogic -p <password> -n sample-domain1-ns -d sample-domain1 -s sample-domain1-weblogic-credentials

3. Navigate to the domain-home-on-pv folder.
   cd ~/occas8/dockerfiles/8.0.0.0.0/occas-domain-home-on-pv/domain-home-on-pv
4. Open the create-domain-inputs.yaml file.
5. Set the following parameters.
   • domainHome—If you set the path parameter of the persistent volume to /u01/pv, then set the domainHome parameter to /u01/pv/domains/sample-domain1.
   • logHome—If you set the path parameter of the persistent volume to /u01/pv, then set the logHome parameter to /u01/pv/logs/sample-domain1.
   • domainPVMountPath—The domainPVMountPath parameter should match the path parameter of the persistent volume.
6. Use the create-domain.sh script to create the domain.
   The command requires two arguments: the input YAML file and the output directory.

   ./create-domain.sh \
       -i create-domain-inputs.yaml \
       -o ~/occas8/dockerfiles/8.0.0.0.0/occas-domain-home-on-pv/domain-home-on-pv

7. Navigvate to the sample-domain1 folder.

   cd weblogic-domains/sample-domain1/

8. Deploy the WebLogic domain in the Kubernetes cluster.

   kubectl apply -f domain.yaml

   The domain will now be managed by the Weblogic Operator.
9. Open a browser and navigate to http://<IP address>:30701/console to visit the WebLogic Server's management interface.

For quick, on-demand changes to your domain, modify the domain.yaml file directly and use kubectl to apply your changes. By modifying the domain file you can scale up or down the number of managed servers, change JMV options, or update the mountPath for your PV.

1. Navigate to the sample-domain1 directory.

   cd ~/occas8/dockerfiles/8.0.0.0.0/occas-domain-home-on-pv/domain-home-on-pv/weblogic-domains/sample-domain1

2. Open the file domain.yaml.
3. Set the replicatas attribute to the number of managed servers you want.
   For example:

   replicas: 2

4. Reapply the domain.yaml file.

   kubectl apply -f domain.yaml

Converged Application Server can integrate with several third-party monitoring tools.

• The EFK stack—The EFK stack is the combination of Elasticsearch, FluentD, and Kibana working together to centralize log files for easy monitoring. FluentD gathers logs files from multiple nodes and sends them to Elasticsearch, which stores and indexes them, while Kibana provides the front-end web interface.
• Prometheus and Grafana—Converged Application Server can use the WebLogic Monitoring Exporter to export Prometheus-compatible metrics that are then exposed to Grafana, which visualizes the metrics over time to provide futher insights into the data.

The Dockerfile in the occas8/dockerfiles/8.0.0.0.0/patch-opatch-update directory extends the Converged Application Server image by updating OPatch and applying a patch. If an update is released for Converged Application Server or one of its components (like WebLogic or Confluence), use OPatch to patch your system.

1. Log in to My Oracle Support.
2. Download the patches for Converged Application Server or one of its components.
3. Identify the top-level folder name within the archive file.
   Syntax:

   unzip -l <zip file> | head

   For example:

   [user@host:~]$ unzip -l p33286174_141100_Generic.zip | head
   Archive:  p33286174_141100_Generic.zip
     Length      Date    Time    Name
   ---------  ---------- -----   ----
           0  09-22-2021 13:08   33286174/
           0  09-21-2021 19:11   33286174/etc/
           0  09-21-2021 19:11   33286174/etc/config/
           0  09-21-2021 19:11   33286174/files/
           0  09-21-2021 19:11   33286174/files/coherence/
           0  09-21-2021 19:11   33286174/files/coherence/bin/
           0  09-21-2021 19:11   33286174/files/coherence/lib/

   In this example, the top-level folder is 33286174.

4. Move the patch files into the occas8/dockerfiles/8.0.0.0.0/patch-opatch-update directory.
   For example:

   mv ~/Downloads/p28186730_139426_Generic.zip ~/occas8/dockerfiles/8.0.0.0.0/patch-opatch-update

5. Update PATCH_PKG variables in the Dockerfile to match the filename of patch files.

   ENV PATCH_PKG0="p28186730_139426_Generic.zip"
   ENV PATCH_PKG1="p33286174_141100_Generic.zip"
   ENV PATCH_PKG2="p33416881_141100_Generic.zip"

6. Update the /u01/<folder> directories within the Dockerfile with the top-level folder names of the patches you're installing.
7. Build the image.

   docker build --force-rm=true --no-cache=true -t oracle/occas:occas-generic-oct2021cpupatch-upgrade -f Dockerfile .