based on docker containers - oracle.com · docker swarm is a cluster of docker engines. docker...

Deploying Containerized JD Edwards EnterpriseOne on Oracle Cloud Infrastructure Based on Docker Containers O R A C L E W H I T E P A P E R | J U L Y 2 0 1 8

DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE

Disclaimer

The following is intended to outline our general product direction. It is intended for information

purposes only, and may not be incorporated into any contract. It is not a commitment to deliver any

material, code, or functionality, and should not be relied upon in making purchasing decisions. The

development, release, and timing of any features or functionality described for Oracle’s products

remains at the sole discretion of Oracle.

0 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE

Table of Contents

Disclaimer 1

Introduction 1

Docker Overview 2

Docker Swarm Mode .......................................................................................................................... 2

Docker Images and Layers ................................................................................................................. 2

Oracle Cloud Infrastructure 3

JD Edwards EnterpriseOne High-Availability Architecture 4

Containerized JD Edwards EnterpriseOne Deployment in Oracle Cloud Infrastructure 5

Creating a Docker Swarm on Oracle Cloud Infrastructure 6

Use Cases 9

High Availability ................................................................................................................................... 9

Hot Upgrades .................................................................................................................................... 10

Elastic Scaling ................................................................................................................................... 13

Load Balancer Configuration for High Availability 14

How to Build JD Edwards EnterpriseOne Docker Images 17

Sample Scripts .................................................................................................................................. 17

Prerequisites ..................................................................................................................................... 62

Oracle Linux Host Pre-requisite Setup ........................................................................................ 63

Windows VM hosts file entry ....................................................................................................... 63

Build image Oracle DB Server 12.1.0.2 SE2 .................................................................................... 64

Build Image Oracle Java 8 ................................................................................................................ 64

Build image Oracle WebLogic 12.2.1.0 ............................................................................................. 64


Generate the SSH keys in OpenSSH format .................................................................................... 64

Build the JDE Base Images .............................................................................................................. 64

Deploy the JD Edwards EnterpriseOne Software Components Using the JD Edwards One-Click

Provisioning Console ........................................................................................................................ 65

Build the JDE Final Images ............................................................................................................... 68

Run the JDE servers ......................................................................................................................... 68

Sample Docker Compose File to Run JD Edwards EnterpriseOne in a Swarm 69

Conclusion 72


Introduction

The cloud application development and deployment paradigm is changing. Docker containers1 make

your operations teams and development teams more agile. By using Docker containers, enterprises

achieve both greater flexibility and lower infrastructure costs. Rather than deploying separate physical

servers or virtual machine (VM) instances, containerizing JD Edwards EnterpriseOne servers enables

efficient usage of available resources. All containers share the OS kernel of the host operating system;

they start instantly and use less RAM. Containers isolate applications from one another and the

underlying infrastructure, and are more streamlined and lightweight compared to VMs. Container

images are constructed from layered file systems and share common files, making disk usage and

image downloads much more efficient. Docker containers are not tied to any specific infrastructure and

can run on any computer, on any infrastructure, and in any cloud. Docker containers provide portability

and guarantee that the software will run the same regardless of its underlying infrastructure (on

premises or in the cloud).

This white paper provides a technical overview of deploying containerized JD Edwards EnterpriseOne

servers in Oracle Cloud Infrastructure to achieve high availability and scalability.

1 Information about Docker containers is based on content from the Docker site.


Docker Overview

Docker provides a lightweight container runtime and robust tooling that helps you build and run your containers.

Docker enables you to package a piece of software and all of its dependencies into an isolated container. All

containers share the OS kernel on the host system, making resource utilization far more efficient.

For more information about containers see the documentation at: https://www.docker.com/what-docker.

Figure 1. Docker Engine

Docker Swarm Mode

Docker swarm is a cluster of Docker engines. Docker swarm mode is available in Docker Engine 1.12 and later.

You can use the Docker command-line interface to create a swarm, deploy services to a swarm, and manage

swarm behavior. Some of the features of Docker swarm mode include:

» Cluster management integrated with Docker Engine

» Scaling

» Desired state reconciliation

» Multi-host networking

» Service discovery

» Load balancing

For more information about Docker swarm mode, see the documentation at: https://docs.docker.com/engine/swarm.

Docker Images and Layers

Docker images reference read-only layers that represent file system differences. These layers are stacked on top of

each other to form a base for the container’s root file system.

For more information about the internal structure of Docker images and layers, see the documentation at:

https://docs.docker.com/engine/userguide/storagedriver/imagesandcontainers.


Figure 2. An example of layers in a JD Edwards EnterpriseOne Server Manager Docker image

Only the layers that change are downloaded (see figure below), making transfers extremely efficient:

Figure 3. A JD Edwards EnterpriseOne Server Manager Docker image being downloaded

Oracle Cloud Infrastructure

Oracle Cloud Infrastructure combines the elasticity and utility of public cloud with the granular control, security, and

predictability of on-premises infrastructure to deliver high-performance, high availability, and cost-effective

infrastructure services.


Figure 4. Oracle Cloud Infrastructure components

Each region has three fault-independent Availability Domains. Each of these Availability Domains contain an

independent data center with power, thermal, and network isolation. Low latency and high-bandwidth interconnect

enables zero-data-loss architectures for applications like Oracle Database.

Figure 5. Oracle Cloud Infrastructure Availability Domains

For more information about Oracle Cloud Infrastructure, see the documentation at:

https://cloud.oracle.com/en_US/infrastructure/architecture.

JD Edwards EnterpriseOne High-Availability Architecture

A typical high-availability architecture for JD Edwards EnterpriseOne servers is shown in Figure 6. The HTML,

Application Interface Services (AIS), and Enterprise servers are logically grouped. These logical groups may be

replicated and load balanced to achieve better reliability and improved performance by distributing traffic across

servers. A failover IP may also be used to seamlessly switch to servers in another availability zone in case of

downtime at one zone.


Figure 6. JD Edwards EnterpriseOne high-availability architecture

Containerized JD Edwards EnterpriseOne Deployment in Oracle Cloud Infrastructure

Figure 7 shows four Docker nodes connected in a swarm configuration. A swarm is a cluster of Docker Engines

where you deploy services. Each node is an instance running Oracle Linux 7.3 with the Docker Engine installed.

Manager nodes perform swarm management while worker nodes only run services. By default, manager nodes are

also configured to run services in addition to managing the swarm. The nodes are spread across three availability

domains. Three of the nodes are configured as manager nodes. This allows the swarm to recover if one manager

node fails. For example, if the primary manager node on AD1 fails, another manager is elected as the leader which

then automatically recovers the desired state of the swarm.

The JD Edwards EnterpriseOne server containers are deployed on the nodes. The HTML, AIS, and Enterprise

servers are logically grouped (shown as three color-coded groups). The HTML and AIS servers may be load

balanced using load balancers such as Oracle Traffic Director (OTD), HAProxy, or NGINX. The DB server is hosted

on an Oracle Cloud Infrastructure DB System for high performance while the Deployment Server is running on a VM

instance.


Figure 7. Containerized JD Edwards EnterpriseOne servers deployed in Oracle Cloud Infrastructure

Creating a Docker Swarm on Oracle Cloud Infrastructure 1. Create the compartment, virtual cloud network (VCN), subnets, and instances.

In Figure 8, the instances dockervm1 and dockervm2 are on AD-1, while dockervm1c and dockervm2c are on AD-3.

2. Edit the security list rules to allow traffic on the ports required by Docker and JD Edwards EnterpriseOne servers. Also ensure that the firewall rules on the OS are modified to open the required ports.

For example:

$ sudo -i

$ iptables -I INPUT -p tcp --dport 2377 -j ACCEPT

Alternately the OS firewall may be disabled by executing the command below as root user.

$ systemctl stop firewalld && systemctl disable firewalld

$ /sbin/iptables -P FORWARD ACCEPT

The ports required by Docker are:

» TCP port 2377 for cluster management communications

» TCP and UDP port 7946 for communication among nodes


» TCP and UDP port 4789 for overlay network traffic

For information about creating Oracle Cloud Infrastructure resources, see the documentation at:

https://docs.us-phoenix-1.oraclecloud.com/Content/home.htm

Figure 8. Instances

3. Attach a 256 GB block storage volume to each instance and partition the volume as ext4 with fdisk.

Figure 9. Block storage volumes


4. Mount the block storage volume instance on each instance:

$ sudo –i

$ mkdir -p /mnt/store

$ mount /dev/sdb1 /mnt/store

$ chown -R opc:opc /mnt/store

5. Install the latest version of Docker on each instance.

$ yum-config-manager --enable ol7_addons

$ yum-config-manager --enable ol7_optional_latest

$ yum -y install docker-engine

$ usermod -aG docker opc

$ curl -L https://github.com/docker/compose/releases/download/1.17.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

$ chmod +x /usr/local/bin/docker-compose

6. Configure Docker to use the overlay2 storage driver.

$ mkdir -p /etc/docker && tee /etc/docker/daemon.json <<- EOF

{

"graph": "/mnt/store/docker",

"storage-driver": "overlay2",

"insecure-registries": ["jderepo:5000","127.0.0.0/8"],

"tls": false,

"hosts": ["unix:///var/run/docker.sock","tcp://0.0.0.0:4243"]

}

EOF

$ systemctl daemon-reload

$ systemctl start docker

7. Initialize the Docker swarm on instance dockervm1 (private IP address 10.0.0.2)

$ docker swarm init --advertise-addr 10.0.0.2

8. Execute the following commands to get the token for other nodes to join the swarm:

$ docker swarm join-token manager

$ docker swarm join-token worker

In this example, dockervm1 and dockervm1c are manager nodes.


Figure 10. Docker swarm nodes

Use Cases

Below are some of the use cases that containerized JD Edwards EnterpriseOne enables:

» Rapid provisioning of instances, which can be used for:

» Development and test purposes

Cloud, local desktop/laptop, private data center

» Training purposes

» General disposable environments

» High availability/on-demand disaster recovery – Spin up new JD Edwards instances that are fully configured and ready to use (with all the required wiring with other running instances) when existing instances go down.

» Hot upgrades – Upgrade JD Edwards instances with near zero downtime.

» Elastic scale up/down – Increase or decrease the number of replicas based on some threshold value such as the total number of connections.

High Availability

When a running service instance fails, the Docker engine automatically launches a new instance to maintain the

desired state (number of replicas). A monitoring script runs in the background and dynamically reconfigures the JD

Edwards logical server groups when a new service instance is launched.

In this example, the environment has four VM instances connected in a swarm.

Figure 11. Docker swarm nodes

There are two replicas of JD Edwards EnterpriseOne server groups (each containing an Enterprise Server, HTML

Web Server, and AIS Server logically linked together). For example, the first logical group consists of containers

entserv.1, webserv.1, and aisserv.1. The servers are load balanced using HAProxy.

Figure 12. JD Edwards EnterpriseOne containerized services

A sample monitoring script is shown below:


while true

do

date

docker service ls -q | xargs -n1 docker service ps | grep Failed | grep -v nginx | grep -v haproxy | grep -v otd | grep 'seconds ago'

if [ $? == "0" ]; then

printf "Failure found\n\n"

./ExecRubyServiceConfigAndLBConf.sh

printf "Configuration updated\n\n"

else

printf "No failure\n\n"

fi

sleep 55

done

With the monitoring script running in the background, simulate a failure by logging in to node dockervm2 and

terminating instance entserv.1.

The Docker engine detects that an instance has failed and automatically launches a new instance with ID

b1xo7i6v3pds9vixqlyy6gpid.

Figure 13. New Enterprise Server container automatically launched by the Docker engine to replace the failed container

The monitoring script detects that a failure occurred and automatically reconfigures/rewires the JD Edwards logical

server groups in a few seconds.

Figure 14. Logical server groups being rewired automatically after a failure

Hot Upgrades

JD Edwards EnterpriseOne server instances can be updated with near zero downtime by using containerized

services.


Figure 15 shows JD Edwards EnterpriseOne v9.2.1.0 servers deployed as a stack named jdeapp. The Web and AIS

servers are load balanced using HAProxy.

Figure 15. JD Edwards EnterpriseOne v9.2.1.0 stack

A sample HAProxy configuration file snippet is shown below. The Web and AIS containers are named s1 and a1 in

the configuration.

frontend http-in-websrv

bind *:7003

option httplog

option logasap

default_backend webservers

backend webservers

mode http

balance roundrobin

cookie JSESSIONID prefix nocache

server s1 jdeapp_jdeweb.1.ucd9deri7bq1mtr0374exj45y:7003 maxconn 32 check cookie s1

frontend http-in-aissrv

bind *:7004

option httplog

option logasap

default_backend aisservers

backend aisservers

mode http

balance roundrobin

stick-table type ip size 20k

stick on src

server a1 jdeapp_jdeais.1.pipc1s0yjwjyfgm8scpa2uc95:7003 maxconn 32 check


The below figure shows a client connected to server s1, identified by the s1~ prefix in the JSESSIONID value.

Figure 16. A client connected to Web Server s1

With the above configuration running, deploy a new stack named jdeappv2 containing version updates or bug fixes.

The new v9.2.1.2 services are named jdewebv2, jdeentv2, and jdeaisv2.

Figure 17. Updated JD Edwards services deployed alongside existing services

The HAProxy configuration is updated as shown below with the new Web and AIS servers being named t1 and b1:


bind *:7003

option httplog

option logasap


backend webservers

mode http

balance roundrobin


server s1 jdeapp_jdeweb.1.ucd9deri7bq1mtr0374exj45y:7003 maxconn 32 check cookie s1

server t1 jdeappv2_jdewebv2.1.xhwvcsja9k288xm2764dzucok:7003 maxconn 32 check cookie


bind *:7004

option httplog

option logasap



backend aisservers

mode http

balance roundrobin

stick-table type ip size 20k

stick on src

server a1 jdeapp_jdeais.1.pipc1s0yjwjyfgm8scpa2uc95:7003 maxconn 32 check

server b1 jdeappv2_jdeaisv2.1.trcq8dq11cncph6uq0e44lbyg:7003 maxconn 32 check

The servers s1 and a1 are then set to a “drain” state (identified by the number 8 in the 7th column).

Figure 18. Web and AIS Servers s1 and a1 in “drain” state

With this configuration, a new client is connected to the updated Web server t1 while a persistent connection

continues to be serviced by s1 until the session terminates.

Figure 19. A new client is connected to updated Web server t1

Elastic Scaling

The JD Edwards EnterpriseOne server instances can be scaled up or down depending on the number of

connections as determined from the load balancer. A monitoring script runs in the background and scales instances

up or down based on the number of active connections to the HAProxy load balancer.

Figure 20. JD Edwards EnterpriseOne containerized services with two replicas

In this example, the script is configured to increase the number of instances when the number of current

connections is greater than a value of 5.


Figure 21. JD Edwards EnterpriseOne containerized services being scaled to a value of 3

Figure 22. JD Edwards EnterpriseOne containerized services with 3 replicas

The script also updates the load balancer configuration to include the third replica.

Load Balancer Configuration for High Availability


JD Edwards EnterpriseOne containers may be deployed using a high availability architecture as shown in Figure 23.

The HTML and AIS servers are load balanced using HTTP mode while the Enterprise Servers are load balanced

using TCP mode. The DB server may be deployed as a container or as an Oracle Cloud Infrastructure DB System.

The hosts file of the HTML and AIS servers is updated with the IP of the load balancer.

Figure 23. JD Edwards EnterpriseOne High Availability

Below is a sample configuration file for the load balancer HAProxy. The Web servers are s1 and s2, the AIS servers

are a1 and a2, and the Enterprise Servers are e1 and e2.

global

daemon

maxconn 30000

log 127.0.0.1 local0

stats socket /var/run/haproxy.sock mode 600 level admin

stats timeout 2m

defaults

mode http

log global

option redispatch

timeout connect 5s

timeout client 60s

timeout server 60s



bind *:7003

option httplog


backend webservers

mode http

option httplog

balance roundrobin


server s1 172.28.5.14:7003 maxconn 32 check cookie s1

server s2 172.28.5.13:7003 maxconn 32 check cookie s2


bind *:7004

option httplog


backend aisservers

mode http

option httplog

balance roundrobin

cookie SERVERID insert indirect nocache

server a1 172.28.5.5:7003 maxconn 32 check cookie a1

server a2 172.28.5.6:7003 maxconn 32 check cookie a2

frontend tcp-in-entsrv

bind *:6017-6027

mode tcp

option tcplog

timeout client 2m

default_backend entservers


backend entservers

mode tcp

option tcplog

balance roundrobin

timeout connect 10s

timeout server 2m

server e1 172.28.5.12

server e2 172.28.5.11

How to Build JD Edwards EnterpriseOne Docker Images

Dockerfiles for Oracle products are available at https://github.com/oracle/docker-images. The following folders are

required for building the base images that are used to deploy JD Edwards EnterpriseOne software:

» OracleJava

» OracleWebLogic

» OracleDatabase

The sequence of building JD Edwards EnterpriseOne Docker images is as follows:

1. Build the Docker base images for Provisioning server, Oracle DB server, Enterprise server, HTML Web server and AIS server.

2. Launch the containers created above by executing the Docker Compose file.

3. Use the JD Edwards One-Click Provisioning Console to deploy the JD Edwards EnterpriseOne software components onto the base images.

4. Commit the containers to create the Docker images for the various JD Edwards EnterpriseOne servers.

5. Backup the DB data volume and Provisioning Server (Server Manager Console) volume.

Sample Scripts

File: OracleJDE/dockerfiles/build-base-images.sh

#!/bin/bash

#

# Author: [email protected]

# Description: Script to build Docker Image containing pre‐requisites for deploying JDE Enterprise

Server software components.

#

# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

#

# Copyright (c) 2017‐2018 Oracle and/or its affiliates. All rights reserved.

#

DIR=`pwd`


REPO="oracle/jde"

WLS_ADMIN_PASSWORD="welcome1"

SSH_PUBLIC_KEY="$DIR/build/ssh_keys/docker_key.pub"

jde_build_image()

{

IMAGE_NAME=$1

BUILD_DIR=$2

# ################## #

# BUILDING THE IMAGE #

# ################## #

echo "Building image '$IMAGE_NAME' ..."

cd $BUILD_DIR

# BUILD THE IMAGE (replace all environment variables)

BUILD_START=$(date '+%s')

docker build ‐t $IMAGE_NAME . || {

echo "There was an error building the image."

exit 1

}

BUILD_END=$(date '+%s')

BUILD_ELAPSED=`expr $BUILD_END ‐ $BUILD_START`

echo ""

if [ $? ‐eq 0 ]; then

cat << EOF

Docker Image is ready to be extended:

‐‐> $IMAGE_NAME

Build completed in $BUILD_ELAPSED seconds.

EOF

else

echo "Docker Image $IMAGE_NAME was NOT successfully created. Check the output and correct any

reported problems with the docker build operation."

fi

}

jde_build_image_wls()

{

IMAGE_NAME=$1


BUILD_DIR=$2

WLSADMIN_PASS=$3

# ################## #


# ################## #


cd $BUILD_DIR



docker build ‐t $IMAGE_NAME ‐‐build‐arg ADMIN_PASSWORD=$WLSADMIN_PASS . || {


exit 1

}



echo ""

if [ $? ‐eq 0 ]; then

cat << EOF


‐‐> $IMAGE_NAME


EOF

else



fi

}

jde_copy_public_key()

{

cp $SSH_PUBLIC_KEY $1

}

cd ../..

ROOT_DIR=`pwd`

echo "Root directory: $ROOT_DIR"

cd $ROOT_DIR/OracleDatabase/SingleInstance/dockerfiles


sed ‐i ‐e 's|FROM oraclelinux:.*|FROM oraclelinux:7|g'

$ROOT_DIR/OracleDatabase/SingleInstance/dockerfiles/12.1.0.2/Dockerfile.se2

chmod 755 buildDockerImage.sh

./buildDockerImage.sh ‐v 12.1.0.2 ‐s

cd $ROOT_DIR/OracleJava/java‐8

sed ‐i ‐e 's|FROM oraclelinux:.*|FROM oraclelinux:7|g' $ROOT_DIR/OracleJava/java‐8/Dockerfile

chmod 755 build.sh

./build.sh

cd $ROOT_DIR/OracleWebLogic/dockerfiles

chmod 755 buildDockerImage.sh

./buildDockerImage.sh ‐v 12.2.1 ‐g

cd $DIR

jde_copy_public_key $DIR/build/oc_jdedb

jde_copy_public_key $DIR/build/oc_jdeprov

jde_copy_public_key $DIR/build/oc_jdeent

jde_copy_public_key $DIR/build/oc_jdeweb

jde_copy_public_key $DIR/build/oc_jdeais

jde_build_image $REPO/oradb:12.1.0.2‐se2‐9.2.2.4‐base $DIR/build/oc_jdedb

jde_build_image $REPO/prov:9.2.2.4‐base $DIR/build/oc_jdeprov

jde_build_image $REPO/ent:9.2.2.4‐base $DIR/build/oc_jdeent

jde_build_image_wls $REPO/web:12.2.1.0‐g‐9.2.2.4‐base $DIR/build/oc_jdeweb $WLS_ADMIN_PASSWORD

jde_build_image_wls $REPO/ais:12.2.1.0‐g‐9.2.2.4‐base $DIR/build/oc_jdeais $WLS_ADMIN_PASSWORD

File: OracleJDE/dockerfiles/build-final-images.sh

#!/bin/bash

#


#


#


#

DIR=`pwd`

REPO="oracle/jde"

DB_DATA_ARCHIVE="/mnt/store/data/prov_prime_9224/jdedb‐9224‐ora12102‐pp‐data‐volume‐orch.tar.gz"

JDEPROV_ARCHIVE="/mnt/store/data/prov_prime_9224/jdeprov‐9224‐pp‐u01‐volume‐smc.tar.gz"


jde_build_image()

{

IMAGE_NAME=$1

BUILD_DIR=$2

# ################## #


# ################## #


cd $BUILD_DIR



docker build ‐t $IMAGE_NAME . || {


exit 1

}



echo ""

if [ $? ‐eq 0 ]; then

cat << EOF


‐‐> $IMAGE_NAME


EOF

else



fi

}

# $1 ‐ file

# $2 ‐ target dir

jde_copy_file()

{

printf "\n Copying $1 to directory $2 \n"

cp $1 $2


}

jde_copy_file $DB_DATA_ARCHIVE $DIR/build/final_jdedb

jde_copy_file ./run/scripts/jdeStartDB.sh $DIR/build/final_jdedb

jde_copy_file $JDEPROV_ARCHIVE $DIR/build/final_jdeprov

jde_copy_file ./run/scripts/jdeStartSMC.sh $DIR/build/final_jdeprov

jde_copy_file ./run/scripts/jdeStartEntServ.sh $DIR/build/final_jdeent

jde_copy_file ./run/scripts/jdeStartWebServ.sh $DIR/build/final_jdeweb

jde_copy_file ./run/scripts/jdeStartAisServ.sh $DIR/build/final_jdeais

jde_build_image $REPO/oradb:12.1.0.2‐se2‐9.2.2.4‐pp‐dv‐s $DIR/build/final_jdedb

jde_build_image $REPO/prov:9.2.2.4‐pp‐dv‐s $DIR/build/final_jdeprov

jde_build_image $REPO/ent:9.2.2.4‐pp‐dv‐s $DIR/build/final_jdeent

jde_build_image $REPO/web:12.2.1.0‐g‐9.2.2.4‐pp‐dv‐s $DIR/build/final_jdeweb

jde_build_image $REPO/ais:12.2.1.0‐g‐9.2.2.4‐pp‐dv‐s $DIR/build/final_jdeais

File: OracleJDE/dockerfiles/docker-compose-deploy-oc.yml

version: '2.1'

services:

jdedb:

hostname: jdedb

container_name: jdedb

image: oracle/jde/oradb:12.1.0.2‐se2‐9.2.2.4‐base

ports:

‐ 1521:1521

‐ 5500:5500

volumes:

‐ jdedb‐9224‐ora12102‐pp‐data‐volume:/opt/oracle/oradata/

networks:

jdenet:

aliases:

‐ jdedb

extra_hosts:

‐ "jdedep:10.0.0.3"

environment:

ORACLE_SID: orcl

ORACLE_PDB: jdeorcl

restart: on‐failure


healthcheck:

disable: true

privileged: true

jdeprov:

hostname: jdeprov

container_name: jdeprov

image: oracle/jde/prov:9.2.2.4‐base

ports:

‐ "3000:3000"

‐ "8999:8999"

‐ "8998:8998"

‐ "7001:7001"

‐ "14501:14501"

‐ "14502:14502"

‐ "137:137"

‐ "138:138"

‐ "139:139"

‐ "445:445"

volumes:

‐ jdeprov‐9224‐pp‐u01‐volume:/u01/

‐ /sys/fs/cgroup:/sys/fs/cgroup:ro

networks:

jdenet:

aliases:

‐ jdeprov

extra_hosts:

‐ "jdedep:10.0.0.3"


depends_on:

jdedb:

condition: service_started

tty: true

privileged: true

jdeent:

hostname: jdeent

container_name: jdeent

image: oracle/jde/ent:9.2.2.4‐base

ports:

‐ "6017‐6027:6017‐6027"

networks:


jdenet:

aliases:

‐ jdeent

extra_hosts:

‐ "jdedep:10.0.0.3"

depends_on:

jdeprov:



jdeweb:

hostname: jdeweb

container_name: jdeweb

image: oracle/jde/web:12.2.1.0‐g‐9.2.2.4‐base

ports:

‐ "7002:7002"

‐ "8002:8002"

‐ "8003:8003"

environment:

‐ NM_HOST=localhost

networks:

jdenet:

aliases:

‐ jdeweb

extra_hosts:

‐ "jdedep:10.0.0.3"

‐ "wlsadmin:127.0.0.1"

depends_on:

jdeent:



jdeais:

hostname: jdeais

container_name: jdeais

image: oracle/jde/ais:12.2.1.0‐g‐9.2.2.4‐base

ports:

‐ "7004:7004"

‐ "8004:8004"

‐ "8005:8005"

environment:



networks:

jdenet:

aliases:

‐ jdeais

extra_hosts:

‐ "jdedep:10.0.0.3"

‐ "wlsadmin:127.0.0.1"

depends_on:

jdeweb:



# docker volume create jdedb‐9224‐ora12102‐pp‐data‐volume

# docker volume create jdeprov‐9224‐pp‐u01‐volume

volumes:

jdedb‐9224‐ora12102‐pp‐data‐volume:

external: true

jdeprov‐9224‐pp‐u01‐volume:

external: true

networks:

jdenet:

driver: bridge

ipam:

driver: default

config:

‐ subnet: 172.28.0.0/16

File: OracleJDE/dockerfiles/jde-helper-shell-functions.sh

#!/bin/bash

#


# Description: Helper shell functions.

#


#


#


# dkrexec jdedb opc

dkrexec()

{

DKR_SHELL="bash"

# if [ "$1" = "jdeent" ]

# then

# DKR_SHELL="ksh"

# fi

docker exec ‐ti ‐u $2 $1 $DKR_SHELL ‐‐login

}

# dkrcmd sshtest root "yum ‐y install openssh‐clients"

dkrcmd()

{

DKR_SHELL="bash"

if [ "$1" = "jdeent" ]

then

DKR_SHELL="ksh"

fi

docker exec ‐u $2 $1 $DKR_SHELL ‐‐login ‐c "$3"

}

dkrcmpup()

{

docker‐compose ‐f docker‐compose‐deploy‐oc.yml up ‐d

sleep 15

jdeent_ip=$(docker exec jdeent cat /etc/hosts | grep ‐o '172.28.0.[0‐9]\{1,3\}')

echo "Updating hosts file of jdeweb with IP of jdeent"

docker exec ‐u 0 jdeweb /bin/bash ‐c "echo '$jdeent_ip jdeent' >> /etc/hosts; cat /etc/hosts"

}

dkrcmpup2()

{

docker‐compose ‐f docker‐compose‐deploy‐oc‐2.yml up ‐d

sleep 15


echo "Updating hosts file of jdeweb with IP of jdeent"

docker exec ‐u 0 jdeweb /bin/bash ‐c "echo '$jdeent_ip jdeent' >> /etc/hosts; cat /etc/hosts"

}

dkrcmpdown()


{

docker‐compose ‐f docker‐compose‐deploy‐oc.yml down

}

dkrcmpdown2()

{

docker‐compose ‐f docker‐compose‐deploy‐oc‐2.yml down

}

dkrstartprereqs()

{

rm ‐f /tmp/jde*.log

dkrcmd jdedb oracle "/opt/oracle/runOracle.sh" >> /tmp/jdedb.log 2>&1 &

sleep 10

dkrcmd jdeweb oracle "./startWebLogic.sh" >> /tmp/jdeweb.log 2>&1 &

sleep 10

dkrcmd jdeais oracle "./startWebLogic.sh" >> /tmp/jdeais.log 2>&1 &

sleep 10

dkrcmd jdeweb oracle "/u01/oracle/createMachine.sh" >> /tmp/jdeweb1.log 2>&1 &

sleep 10

dkrcmd jdeais oracle "/u01/oracle/createMachine.sh" >> /tmp/jdeais1.log &

sleep 10

# dkrcmd jdeweb oracle "./bin/stopNodeManager.sh"

# dkrcmd jdeweb oracle "./bin/startNodeManager.sh"

# dkrcmd jdeais oracle "./bin/stopNodeManager.sh"

# dkrcmd jdeais oracle "./bin/startNodeManager.sh"

}

dkrcommit()

{

echo "Stopping management agents"

dkrcmd jdedb oracle "/u01/jde_home/SCFHA/bin/stopAgent"

dkrcmd jdeent jde920 "/u01/jde920/jde_home/SCFHA/bin/stopAgent"

dkrcmd jdeweb oracle "/u01/jde_home/SCFHA/bin/stopAgent"

dkrcmd jdeais oracle "/u01/jde_home/SCFHA/bin/stopAgent"

echo "Deleting temp installer files from jdedb"

dkrcmd jdedb root "rm ‐rf /u01/zips"

echo "Changing permissions of /u01 in jdedb"


dkrcmd jdedb root "chown ‐R oracle:dba /u01"

echo "Deleting temp installer files from jdeent"

dkrcmd jdeent root "rm ‐rf /u01/oracle_install /u01/zips"

echo "Creating image oracle/jde/oradb:12.1.0.2‐se2‐9.2.2.4‐pp‐dv"

docker commit jdedb oracle/jde/oradb:12.1.0.2‐se2‐9.2.2.4‐pp‐dv

echo "Creating image oracle/jde/prov:9.2.2.4‐pp‐dv"

docker commit jdeprov oracle/jde/prov:9.2.2.4‐pp‐dv

echo "Creating image oracle/jde/ent:9.2.2.4‐pp‐dv"

docker commit jdeent oracle/jde/ent:9.2.2.4‐pp‐dv

echo "Creating image oracle/jde/web:12.2.1.0‐g‐9.2.2.4‐pp‐dv"

docker commit jdeweb oracle/jde/web:12.2.1.0‐g‐9.2.2.4‐pp‐dv

echo "Creating image oracle/jde/ais:12.2.1.0‐g‐9.2.2.4‐pp‐dv"

docker commit jdeais oracle/jde/ais:12.2.1.0‐g‐9.2.2.4‐pp‐dv

# echo "Starting management agents"

# dkrcmd jdedb oracle "/u01/jde_home/SCFHA/bin/startAgent"

# dkrcmd jdeent jde920 "/u01/jde920/jde_home/SCFHA/bin/startAgent"

# dkrcmd jdeweb oracle "/u01/jde_home/SCFHA/bin/startAgent"

# dkrcmd jdeais oracle "/u01/jde_home/SCFHA/bin/startAgent"

}

dkrstartjde()

{


dkrcmd jdedb oracle "/u01/jde_home/SCFHA/bin/startAgent"


dkrcmd jdeent jde920 "/u01/jde920/jde_home/SCFHA/bin/startAgent"


dkrcmd jdeweb oracle "/u01/jde_home/SCFHA/bin/startAgent"


dkrcmd jdeais oracle "/u01/jde_home/SCFHA/bin/startAgent"


dkrcmd jdedb oracle "/opt/oracle/runOracle.sh" &

}

dkrstartagents()

{


dkrcmd jdeent jde920 "/u01/jde920/jde_home/SCFHA/bin/startAgent"

dkrcmd jdeweb oracle "/u01/jde_home/SCFHA/bin/startAgent"

dkrcmd jdeais oracle "/u01/jde_home/SCFHA/bin/startAgent"

}

dkrstopagents()

{





}

dkrfixagent()

{

CONTAINER=$1

USER=$2

AGENT_HOME=$3

echo "Setting agent to Non‐SSL port for $CONTAINER"

dkrcmd $CONTAINER $USER "sed ‐i ‐e

's|management.server.httpport=.*|management.server.httpport=8999|g'

$AGENT_HOME/config/agent.properties"

dkrcmd $CONTAINER $USER "sed ‐i ‐e

's|management.server.usingssl=.*|management.server.usingssl=false|g'

$AGENT_HOME/config/agent.properties"

dkrcmd $CONTAINER $USER "$AGENT_HOME/bin/stopAgent"

dkrcmd $CONTAINER $USER "$AGENT_HOME/bin/startAgent"

}

dkrfixagents()

{

dkrfixagent jdedb oracle "/u01/jde_home/SCFHA"

dkrfixagent jdeent jde920 "/u01/jde920/jde_home/SCFHA"

dkrfixagent jdeweb oracle "/u01/jde_home/SCFHA"


dkrfixagent jdeais oracle "/u01/jde_home/SCFHA"

}

File: OracleJDE/dockerfiles/orchestration.json

{

"depServer": [

{

"instanceName": "DEP",

"serviceType": "VM",

"hostDetails": {

"serviceName": "jdedep",

"userName": "opc",

"password":

"ACHCJKGEHCJKCEAGGFKGODNIBNDPLJPAJAICDLMKGIGHPFCCHFNGPCAJANGLIEOIPPGONCDDPNDD",

"osPlatform": "WINDOWS"

},

"serverDetails": {

"dependentServer": "DB",

"pathcodes": [

"DEVELOPMENT",

"PRISTINE",

"PROTOTYPE",

"PRODUCTION"

],

"jdeLocation": "DENVER",

"setupDrive": "C:"

}

}

],

"databaseServer": [

{

"instanceName": "DB",


"hostDetails": {

"serviceName": "jdedb",

"osPlatform": "LINUX"

},

"serverDetails": {

"type": "ORACLE",

"adminPassword": "ACHCJKBHHCJKACMAEGJNFJPPFIDEPDPKLHJDBEKPCIKM",

"schemaPassword": "",


"installSchemas": [

"SHARED",

"DEVELOPMENT"

],

"installDemoData": [

"DEVELOPMENT"

],

"dbInstallPath": "/opt/oracle/product/12.1.0.2/dbhome_1",

"tnsName": "JDEORCL",

"sid": "JDEORCL",

"oraDBInstallDir": "/opt/oracle/oradata/jdedb",

"dbIsUseASM": false,

"oraDBTableDir": "/opt/oracle/oradata/jdetable",

"oraDBIndexDir": "/opt/oracle/oradata/jdeindex"

}

}

],

"entServer": [

{

"instanceName": "ENT",


"hostDetails": {

"serviceName": "jdeent",


},

"serverDetails": {


"pathcodes": [

"DEVELOPMENT"

],

"objType": [

"UBE",

"LOGIC"

]

}

}

],

"webServer": [

{

"instanceName": "JAS",


"hostDetails": {


"serviceName": "jdeweb",


},

"serverDetails": {

"instanceType": "jasServer",

"wlsUserName": "weblogic",

"wlsPassword": "ACHCJKBHHCJKMJGFLGAILAJIJKEHLFKPGMCOGPGKNJGI",

"wlsAdminPort": "7002",

"wlsPath": "/u01/oracle",

"jdkPath": "/usr/java/jdk1.8.0_172",

"contentPort": "8002",

"securedContentPort": "8003",

"dependentServer": "ENT",

"pathcode": "DEVELOPMENT",

"enableClustering": false

}

},

{

"instanceName": "AIS",


"hostDetails": {

"serviceName": "jdeais",


},

"serverDetails": {

"instanceType": "aisServer",


"wlsPassword": "ACHCJKDCHCJKLAIFBAGCCHMLIDIBFLDMPJNJOCCMPDPD",






"dependentServer": "JAS",


}

}

],

"devClient": [],

"bipServer": []

}


File: OracleJDE/dockerfiles/orchestration_no_depsrv.json

{

"depServer": [],

"databaseServer": [

{

"instanceName": "DB",


"hostDetails": {

"serviceName": "jdedb",


},

"serverDetails": {

"type": "ORACLE",

"adminPassword": "ACHCJKBHHCJKACMAEGJNFJPPFIDEPDPKLHJDBEKPCIKM",

"schemaPassword": "",

"installSchemas": [

"SHARED",

"DEVELOPMENT"

],

"installDemoData": [

"DEVELOPMENT"

],

"dbInstallPath": "/opt/oracle/product/12.1.0.2/dbhome_1",

"tnsName": "JDEORCL",

"sid": "JDEORCL",

"oraDBInstallDir": "/opt/oracle/oradata/jdedb",

"dbIsUseASM": false,

"oraDBTableDir": "/opt/oracle/oradata/jdetable",

"oraDBIndexDir": "/opt/oracle/oradata/jdeindex"

}

}

],

"entServer": [

{

"instanceName": "ENT",


"hostDetails": {

"serviceName": "jdeent",


},

"serverDetails": {



"pathcodes": [

"DEVELOPMENT"

],

"objType": [

"UBE",

"LOGIC"

]

}

}

],

"webServer": [

{

"instanceName": "JAS",


"hostDetails": {

"serviceName": "jdeweb",


},

"serverDetails": {

"instanceType": "jasServer",


"wlsPassword": "ACHCJKBHHCJKMJGFLGAILAJIJKEHLFKPGMCOGPGKNJGI",






"dependentServer": "ENT",

"pathcode": "DEVELOPMENT",


}

},

{

"instanceName": "AIS",


"hostDetails": {

"serviceName": "jdeais",


},

"serverDetails": {

"instanceType": "aisServer",



"wlsPassword": "ACHCJKDCHCJKLAIFBAGCCHMLIDIBFLDMPJNJOCCMPDPD",






"dependentServer": "JAS",


}

}

],

"devClient": [],

"bipServer": []

}

File: OracleJDE/dockerfiles/build/oc_jdeais/create-opc-user.sh

File: OracleJDE/dockerfiles/build/oc_jdedb/create-opc-user.sh

File: OracleJDE/dockerfiles/build/oc_jdeent/create-opc-user.sh

File: OracleJDE/dockerfiles/build/oc_jdeprov/create-opc-user.sh

File: OracleJDE/dockerfiles/build/oc_jdeweb/create-opc-user.sh

#!/bin/bash

__create_user() {

useradd opc

SSH_USERPASS=opc

echo ‐e "$SSH_USERPASS\n$SSH_USERPASS" | (passwd ‐‐stdin opc)

echo ssh user password: $SSH_USERPASS

}

__create_user

File: OracleJDE/dockerfiles/build/oc_jdedb/bash_profile

# .bash_profile

# Get the aliases and functions

if [ ‐f ~/.bashrc ]; then


. ~/.bashrc

fi

# User specific environment and startup programs

PATH=$PATH:$HOME/.local/bin:$HOME/bin

export PATH

export ORACLE_HOME=/opt/oracle/product/12.1.0.2/dbhome_1

export ORACLE_SID=orcl

PATH=$ORACLE_HOME/bin:$PATH:$HOME/.local/bin:$HOME/bin

export PATH

File: OracleJDE/dockerfiles/build/oc_jdedb/Dockerfile

# LICENSE CDDL 1.0 + GPL 2.0

#

# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.

#

# ORACLE DOCKERFILES PROJECT

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

# This Dockerfile builds a Docker Image containing pre‐requisites for deploying JDE DB Server

software components.

#

# Pull base image

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

FROM oracle/database:12.1.0.2‐se2

LABEL maintainer="Noel DCosta <[email protected]>"

USER root

RUN yum ‐y install zip.x86_64 unzip.x86_64 nmap bind‐utils ksh.x86_64 \

compat‐libcap1.x86_64 compat‐libstdc++‐33.x86_64 gcc‐c++.x86_64 \

gcc.x86_64 glibc.x86_64 glibc‐devel.x86_64 glibc.i686 \

libaio.x86_64 libaio‐devel.x86_64 libgcc.x86_64 libstdc++.x86_64 \

libstdc++‐devel.x86_64 libX11.x86_64 libXau.x86_64 libxcb.x86_64 \

libXext.x86_64 libXi.x86_64 libXtst.x86_64 make.x86_64 sysstat.x86_64 \

openssh‐server sudo passwd vi telnet file which net‐tools; yum ‐y clean all

RUN mkdir /u01 && chmod 770 /u01 && \


sed ‐i ‐e "s|kernel.sem.*|kernel.sem = 1024 32000 100 1024|g" /etc/sysctl.conf

ADD ./create‐opc‐user.sh /create‐opc‐user.sh

ADD ./bash_profile /home/oracle/.bash_profile

RUN mkdir /var/run/sshd && ssh‐keygen ‐t rsa ‐f /etc/ssh/ssh_host_rsa_key ‐N '' && \

chmod 755 /create‐opc‐user.sh && /create‐opc‐user.sh && \

groupadd oracle && usermod ‐a ‐G oracle oracle && usermod ‐a ‐G oracle opc && \

chown oracle:oracle /u01 && \

chown oracle:dba /home/oracle/.bash_profile && chmod 644 /home/oracle/.bash_profile && \

cat /home/oracle/.bash_profile

ADD ./docker_key.pub /home/opc/.ssh/authorized_keys

RUN > /home/opc/.ssh/known_hosts && chown ‐R opc:opc /home/opc/.ssh/ && \

chmod 600 /home/opc/.ssh/authorized_keys && ls ‐al /home/opc/.ssh/ && \

sed ‐i ‐e "s|.*ClientAliveInterval.*|ClientAliveInterval 3600|g" /etc/ssh/sshd_config && \

sed ‐i ‐e "s|.*AddressFamily.*|AddressFamily inet|g" /etc/ssh/sshd_config && \

echo "opc ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers

# Fix bug complaining that the sshd directory needs to be owned by root

RUN mkdir ‐p /var/empty/sshd/ && chown ‐R root:root /var/empty/sshd/

CMD ["/usr/sbin/sshd", "‐D"]

File: OracleJDE/dockerfiles/build/oc_jdeais/Dockerfile

# LICENSE UPL 1.0

#


#


# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

# This Dockerfile extends the Oracle WebLogic image by creating a sample domain.

#

# Util scripts are copied into the image enabling users to plug NodeManager

# automatically into the AdminServer running on another container.

#

# HOW TO BUILD THIS IMAGE

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐


# Put all downloaded files in the same directory as this Dockerfile

# Run:

# $ sudo docker build ‐t oracle/jde/ais:ol7‐wls12210‐1 ‐‐build‐arg ADMIN_PASSWORD=welcome1 .

#

# Pull base image

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

FROM oracle/weblogic:12.2.1‐generic

# Maintainer

# ‐‐‐‐‐‐‐‐‐‐


# WLS Configuration (editable during build time)

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

ARG ADMIN_PASSWORD

ARG ADMIN_NAME

ARG DOMAIN_NAME

ARG ADMIN_PORT

ARG CLUSTER_NAME

ARG DEBUG_FLAG

ARG PRODUCTION_MODE

# WLS Configuration (editable during runtime)

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

ENV ADMIN_HOST="wlsadmin" \

NM_PORT="5556" \

MS_PORT="8004" \

DEBUG_PORT="8453" \

CONFIG_JVM_ARGS="‐Dweblogic.security.SSL.ignoreHostnameVerification=true"

# WLS Configuration (persisted. do not change during runtime)

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

ENV DOMAIN_NAME="${DOMAIN_NAME:‐base_domain}" \

DOMAIN_HOME=/u01/oracle/user_projects/domains/${DOMAIN_NAME:‐base_domain} \

ADMIN_NAME="${ADMIN_NAME:‐AdminServer}" \

ADMIN_PORT="7004" \

ADMIN_PASSWORD="${ADMIN_PASSWORD:‐welcome1}" \

CLUSTER_NAME="${CLUSTER_NAME:‐DockerCluster}" \

debugFlag="${DEBUG_FLAG:‐false}" \

PRODUCTION_MODE="${PRODUCTION_MODE:‐prod}" \


PATH=$PATH:/u01/oracle/oracle_common/common/bin:/u01/oracle/wlserver/common/bin:/u01/oracle/user_p

rojects/domains/${DOMAIN_NAME:‐base_domain}/bin:/u01/oracle

# Add files required to build this image

COPY container‐scripts/* /u01/oracle/

USER root

RUN chown ‐R oracle:oracle /u01/oracle/ && chmod 755 /u01/oracle/wlst

USER oracle

# Configuration of WLS Domain

RUN /u01/oracle/wlst /u01/oracle/create‐wls‐domain.py && \

mkdir ‐p /u01/oracle/user_projects/domains/$DOMAIN_NAME/servers/AdminServer/security && \

echo "username=weblogic" >

/u01/oracle/user_projects/domains/$DOMAIN_NAME/servers/AdminServer/security/boot.properties && \

echo "password=$ADMIN_PASSWORD" >>


echo ". /u01/oracle/user_projects/domains/$DOMAIN_NAME/bin/setDomainEnv.sh" >>

/u01/oracle/.bashrc

# Expose Node Manager default port, and also default for admin and managed server

EXPOSE $NM_PORT $ADMIN_PORT $MS_PORT $DEBUG_PORT

WORKDIR $DOMAIN_HOME

# Define default command to start bash.

# CMD ["startWebLogic.sh"]

# JDE pre‐requisites


USER root

RUN yum ‐y update; yum clean all

RUN yum install ‐y zip.x86_64 unzip.x86_64 nmap bind‐utils ksh.x86_64 \

zlib‐devel.x86_64 glibc.x86_64 glibc‐devel.x86_64 glibc.i686 \

sudo passwd vi telnet openssh‐server file which net‐tools; yum ‐y clean all


RUN mkdir /var/run/sshd && \

ssh‐keygen ‐t rsa ‐f /etc/ssh/ssh_host_rsa_key ‐N '' && \

chmod 755 /create‐opc‐user.sh && \

/create‐opc‐user.sh && \

chmod 770 /u01 && \

usermod ‐a ‐G oracle opc && \

groupadd dba && usermod ‐a ‐G dba oracle && \

chown ‐R oracle:oracle /usr/java/ && \

chmod 755 /u01/oracle/*.sh










File: OracleJDE/dockerfiles/build/oc_jdeent/Dockerfile


#


#


# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

# This Dockerfile builds a Docker Image containing pre‐requisites for deploying JDE Enterprise

Server software components.

#

# Pull base image

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

FROM oraclelinux:7








groupadd dba && groupadd oracle && groupadd oneworld && \

useradd ‐d /home/oracle ‐m ‐s /bin/bash ‐g oracle oracle && \

useradd ‐d /home/jde920 ‐m ‐s /bin/ksh ‐g oneworld jde920 && \

usermod ‐a ‐G oracle jde920 && \

usermod ‐a ‐G dba oracle && \


mkdir /u01 && chmod 770 /u01 && chown opc:oracle /u01

# RUN yum ‐y update; yum clean all

# RUN yum install ‐y glibc‐2.17‐196.el7.i686; yum clean all

RUN yum install ‐y ncompress zip.x86_64 unzip.x86_64 nmap bind‐utils \

compat‐libcap1.x86_64 compat‐libstdc++‐33.x86_64 elfutils‐libelf‐devel.x86_64 \

gcc‐c++.x86_64 gcc.x86_64 glibc.x86_64 glibc‐devel.x86_64 ksh.x86_64 \

libaio.x86_64 libaio‐devel.x86_64 libgcc.x86_64 libstdc++.x86_64 libstdc++‐devel.x86_64 \

libX11.x86_64 libXau.x86_64 libxcb.x86_64 libXext.x86_64 libXi.x86_64 libXtst.x86_64 \

make.x86_64 sysstat.x86_64 unixODBC‐devel.x86_64 unixODBC.x86_64 zlib‐devel.x86_64 \

zlib‐devel.i686 compat‐libstdc++‐33.i686 glibc.i686 glibc‐devel.i686 libaio.i686 \

libaio‐devel.i686 libgcc.i686 libstdc++.i686 libX11.i686 libXau.i686 libxcb.i686 \

libXext.i686 libXi.i686 libXtst.i686 nss‐softokn‐freebl.i686 zlib.i686 \











File: OracleJDE/dockerfiles/build/oc_jdeprov/Dockerfile



#


#


# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

# This Dockerfile builds a Docker Image containing pre‐requisites for deploying JDE Provisioning

Server.

#

# Pull base image

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

FROM oraclelinux:7



RUN mkdir /var/run/sshd && ssh‐keygen ‐t rsa ‐f /etc/ssh/ssh_host_rsa_key ‐N '' && \

chmod 755 /create‐opc‐user.sh && /create‐opc‐user.sh && \

yum‐config‐manager ‐‐enable ol7_optional_latest && \

yum install ‐y zip.x86_64 unzip.x86_64 ruby.x86_64 ruby‐devel.x86_64 samba.x86_64 samba‐

client.x86_64 \

nmap bind‐utils ksh.x86_64 gcc‐c++.x86_64 gcc.x86_64 zlib‐devel.x86_64 openssl openssh‐clients

\

sudo passwd initscripts openssh‐server vi telnet file which net‐tools; yum ‐y clean all

RUN groupadd dba && groupadd oracle && \

useradd ‐d /home/oracle ‐m ‐s /bin/bash ‐g oracle oracle && \

usermod ‐a ‐G dba oracle && \


mkdir /u01 && chmod 770 /u01 && chown opc:oracle /u01







RUN gem install ‐v 1.8.1 ‐r winrm

# https://serverfault.com/questions/824975/failed‐to‐get‐d‐bus‐connection‐operation‐not‐permitted


ENV container docker

RUN (cd /lib/systemd/system/sysinit.target.wants/; for i in *; do [ $i == \

systemd‐tmpfiles‐setup.service ] || rm ‐f $i; done); \

rm ‐f /lib/systemd/system/multi‐user.target.wants/*;\

rm ‐f /etc/systemd/system/*.wants/*;\

rm ‐f /lib/systemd/system/local‐fs.target.wants/*; \

rm ‐f /lib/systemd/system/sockets.target.wants/*udev*; \

rm ‐f /lib/systemd/system/sockets.target.wants/*initctl*; \

rm ‐f /lib/systemd/system/basic.target.wants/*;\

rm ‐f /lib/systemd/system/anaconda.target.wants/*;

# Install anything. The service you want to start must be a SystemD service.

RUN systemctl enable sshd.service

# You could have System is booting up. See pam_nologin(8) if your using the PAM system, in that

case,

# delete /usr/lib/tmpfiles.d/systemd‐nologin.conf in your Dockerfile because it creates the file

/var/run/nologin

# which generates this specific error.

RUN rm ‐f /usr/lib/tmpfiles.d/systemd‐nologin.conf



# ENTRYPOINT and CMD are concatenated. Since the ssh base image uses ENTRYPOINT we need to

overwrite it

# ENTRYPOINT ["/usr/sbin/sshd", "‐D"]

# CMD ["/usr/sbin/init"]

CMD ["/usr/sbin/init"]

File: OracleJDE/dockerfiles/build/oc_jdeweb/Dockerfile

#Copyright (c) 2014‐2018 Oracle and/or its affiliates. All rights reserved.

#

#Licensed under the Universal Permissive License v 1.0 as shown at

http://oss.oracle.com/licenses/upl.

#


# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

# This Dockerfile extends the Oracle WebLogic image by creating a sample domain.

#


# Util scripts are copied into the image enabling users to plug NodeManager

# automatically into the AdminServer running on another container.

#

# HOW TO BUILD THIS IMAGE

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

# Put all downloaded files in the same directory as this Dockerfile

# Run:

# $ sudo docker build ‐t oracle/jde/web:ol7‐wls12210‐1 ‐‐build‐arg ADMIN_PASSWORD=welcome1 .

#

# Pull base image

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

FROM oracle/weblogic:12.2.1‐generic

# Maintainer

# ‐‐‐‐‐‐‐‐‐‐


# WLS Configuration (editable during build time)

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

ARG ADMIN_PASSWORD

ARG ADMIN_NAME

ARG DOMAIN_NAME

ARG ADMIN_PORT

ARG CLUSTER_NAME

ARG DEBUG_FLAG

ARG PRODUCTION_MODE

# WLS Configuration (editable during runtime)

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

ENV ADMIN_HOST="wlsadmin" \

NM_PORT="5556" \

MS_PORT="8002" \

DEBUG_PORT="8453" \

CONFIG_JVM_ARGS="‐Dweblogic.security.SSL.ignoreHostnameVerification=true"

# WLS Configuration (persisted. do not change during runtime)

# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

ENV DOMAIN_NAME="${DOMAIN_NAME:‐base_domain}" \

DOMAIN_HOME=/u01/oracle/user_projects/domains/${DOMAIN_NAME:‐base_domain} \

ADMIN_NAME="${ADMIN_NAME:‐AdminServer}" \

ADMIN_PORT="7002" \

ADMIN_PASSWORD="${ADMIN_PASSWORD:‐welcome1}" \


CLUSTER_NAME="${CLUSTER_NAME:‐DockerCluster}" \

debugFlag="${DEBUG_FLAG:‐false}" \

PRODUCTION_MODE="${PRODUCTION_MODE:‐prod}" \

PATH=$PATH:/u01/oracle/oracle_common/common/bin:/u01/oracle/wlserver/common/bin:/u01/oracle/user_p

rojects/domains/${DOMAIN_NAME:‐base_domain}/bin:/u01/oracle

# Add files required to build this image

COPY container‐scripts/* /u01/oracle/

USER root

RUN chown ‐R oracle:oracle /u01/oracle/ && chmod 755 /u01/oracle/wlst

USER oracle

# Configuration of WLS Domain

RUN /u01/oracle/wlst /u01/oracle/create‐wls‐domain.py && \

mkdir ‐p /u01/oracle/user_projects/domains/$DOMAIN_NAME/servers/AdminServer/security && \

echo "username=weblogic" >


echo "password=$ADMIN_PASSWORD" >>


echo ". /u01/oracle/user_projects/domains/$DOMAIN_NAME/bin/setDomainEnv.sh" >>

/u01/oracle/.bashrc

# Expose Node Manager default port, and also default for admin and managed server

EXPOSE $NM_PORT $ADMIN_PORT $MS_PORT $DEBUG_PORT

WORKDIR $DOMAIN_HOME

# Define default command to start bash.

# CMD ["startWebLogic.sh"]

# JDE pre‐requisites


USER root

RUN yum ‐y update; yum clean all

RUN yum install ‐y zip.x86_64 unzip.x86_64 nmap bind‐utils ksh.x86_64 \


zlib‐devel.x86_64 glibc.x86_64 glibc‐devel.x86_64 glibc.i686 \






chmod 770 /u01 && \


groupadd dba && usermod ‐a ‐G dba oracle && \

chown ‐R oracle:oracle /usr/java/ && \

chmod 755 /u01/oracle/*.sh










File: OracleJDE/dockerfiles/build/final_jdeais/Dockerfile


#


#


# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

FROM oracle/jde/ais:12.2.1.0‐g‐9.2.2.4‐pp‐dv

ENV MGMT_AGENT_HOME="/u01/jde_home/SCFHA" \

REST_INI1="/u01/oracle/user_projects/domains/base_domain/servers/AIS_server/stage/AIS/app/JDERestP

roxy.war/WEB‐INF/classes/rest.ini" \

REST_INI2="/u01/jde_home/SCFHA/targets/AIS/config/rest.ini" \


REST_INI3="/u01/jde_home/SCFHA/targets/AIS/owl_deployment/JDERestProxy.ear/app/JDERestProxy.war/WE

B‐INF/classes/rest.ini"

ADD jdeStartAisServ.sh /scripts/jdeStartAisServ.sh

USER root

RUN chown ‐R oracle:oracle /scripts/ && chmod 755 /scripts/*.sh && \

sed ‐i ‐e 's|AdminURL=.*|AdminURL=http\\://127.0.0.1\\:7004|g'

/u01/oracle/user_projects/domains/base_domain/servers/AIS_server/data/nodemanager/startup.properti

es && \

cat

/u01/oracle/user_projects/domains/base_domain/servers/AIS_server/data/nodemanager/startup.properti

es && \

sed ‐i ‐e 's|JasProtocol=.*|JasProtocol=http|g' ${REST_INI1} && \



sed ‐i ‐e 's|JasPort=.*|JasPort=8002|g' ${REST_INI1} && \



sed ‐i ‐e 's|SecurityServer=.*|SecurityServer=jdeent|g' ${REST_INI1} && \



sed ‐i ‐e 's|management.server.httpport=.*|management.server.httpport=8999|g'

${MGMT_AGENT_HOME}/config/agent.properties && \

sed ‐i ‐e 's|management.server.usingssl=.*|management.server.usingssl=false|g'


rm ‐f ${MGMT_AGENT_HOME}/agent.pid && \

rm ‐f ${MGMT_AGENT_HOME}/logs/*.log*

USER oracle

CMD /scripts/jdeStartAisServ.sh

File: OracleJDE/dockerfiles/build/final_jdedb/Dockerfile


#


#


# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐


FROM oracle/jde/oradb:12.1.0.2‐se2‐9.2.2.4‐pp‐dv


DB_DATA_ARCHIVE="jdedb‐9224‐ora12102‐pp‐data‐volume.tar.gz"

ADD jdeStartDB.sh /scripts/jdeStartDB.sh

USER root








# RUN chown ‐R oracle:dba /u01/

COPY ${DB_DATA_ARCHIVE} /u01/

USER oracle

CMD /scripts/jdeStartDB.sh

File: OracleJDE/dockerfiles/build/final_jdeent/Dockerfile


#


#


# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

FROM oracle/jde/ent:9.2.2.4‐pp‐dv

ENV MGMT_AGENT_HOME="/u01/jde920/jde_home/SCFHA"

ADD jdeStartEntServ.sh /scripts/jdeStartEntServ.sh

USER root


RUN chown ‐R jde920:oneworld /scripts/ && chmod 755 /scripts/*.sh && \

cp /home/jde920/.profile /etc/profile.d/jdeenv.sh && \

sed ‐i ‐e "s/enablePredefinedPorts=.*/enablePredefinedPorts=1/g" /u01/jde920/e920/ini/JDE.INI

&& \







USER jde920

WORKDIR /u01/jde920/e920

CMD /scripts/jdeStartEntServ.sh

File: OracleJDE/dockerfiles/build/final_jdeprov/Dockerfile


#


#


# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

FROM oracle/jde/prov:9.2.2.4‐base

ENV MGMT_AGENT_HOME="/u01/SMConsole/SCFMC"

ARG JDEPROV_ARCHIVE="jdeprov‐9224‐pp‐u01‐volume‐smc.tar.gz"

ADD jdeStartSMC.sh /scripts/jdeStartSMC.sh

USER root

RUN chown ‐R oracle:oracle /scripts/ && chmod 755 /scripts/*.sh

ADD ${JDEPROV_ARCHIVE} /u01/

USER oracle

CMD /scripts/jdeStartSMC.sh


File: OracleJDE/dockerfiles/build/final_jdeweb/Dockerfile


#


#


# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

FROM oracle/jde/web:12.2.1.0‐g‐9.2.2.4‐pp‐dv


JAS_INI1="/u01/oracle/user_projects/domains/base_domain/servers/JAS_server/stage/JAS/app/webclient

.war/WEB‐INF/classes/jas.ini" \

JAS_INI2="/u01/jde_home/SCFHA/targets/JAS/config/jas.ini" \

JAS_INI3="/u01/jde_home/SCFHA/targets/JAS/owl_deployment/webclient.ear/app/webclient.war/WEB‐

INF/classes/jas.ini"

ADD jdeStartWebServ.sh /scripts/jdeStartWebServ.sh

USER root


sed ‐i ‐e 's|AdminURL=.*|AdminURL=http\\://127.0.0.1\\:7002|g'

/u01/oracle/user_projects/domains/base_domain/servers/JAS_server/data/nodemanager/startup.properti

es && \

cat

/u01/oracle/user_projects/domains/base_domain/servers/JAS_server/data/nodemanager/startup.properti

es && \





sed ‐i ‐e 's|AISProtocol=.*|AISProtocol=http|g' ${JAS_INI1} && \



sed ‐i ‐e 's|AISPort=.*|AISPort=8004|g' ${JAS_INI1} && \






USER oracle

CMD /scripts/jdeStartWebServ.sh

File: OracleJDE/dockerfiles/run/docker-compose-run-oc-s-9224.yml

version: '3.1'

services:

jdedb:

hostname: jdedb

container_name: jdedb

image: oracle/jde/oradb:12.1.0.2‐se2‐9.2.2.4‐pp‐dv‐s

user: oracle

ports:

‐ 1521:1521

‐ 5500:5500

secrets:

‐ source: jdedb_system_password

target: /etc/secret‐volume/jdedb_system_password

volumes:


networks:

jdenet:

aliases:

‐ jdedb

extra_hosts:

‐ "jdedep:10.0.0.5"

environment:

ORACLE_SID: orcl

ORACLE_PDB: jdeorcl


jdeprov:

hostname: jdeprov

container_name: jdeprov

image: oracle/jde/prov:9.2.2.4‐pp‐dv‐s

user: oracle

ports:

‐ "3000:3000"


‐ "8999:8999"

‐ "8998:8998"

‐ "7001:7001"

‐ "14501:14501"

‐ "14502:14502"

secrets:



‐ source: wlsadmin_password

target: /etc/secret‐volume/wlsadmin_password

networks:

jdenet:

aliases:

‐ jdeprov

extra_hosts:

‐ "jdedep:10.0.0.5"


depends_on:

‐ jdedb

jdeent:

hostname: jdeent

container_name: jdeent

image: oracle/jde/ent:9.2.2.4‐pp‐dv‐s

user: jde920

ports:

‐ "6017‐6027:6017‐6027"

secrets:



networks:

jdenet:

aliases:

‐ jdeent

extra_hosts:

‐ "jdedep:10.0.0.5"

depends_on:

‐ jdeprov


jdeweb:

hostname: jdeweb


container_name: jdeweb

image: oracle/jde/web:12.2.1.0‐g‐9.2.2.4‐pp‐dv‐s

user: oracle

ports:

‐ "7002:7002"

‐ "8002:8002"

‐ "8003:8003"

secrets:



environment:


networks:

jdenet:

aliases:

‐ jdeweb

extra_hosts:

‐ "jdedep:10.0.0.5"

‐ "jdeent:172.28.0.4"

‐ "wlsadmin:127.0.0.1"

depends_on:

‐ jdeent


jdeais:

hostname: jdeais

container_name: jdeais

image: oracle/jde/ais:12.2.1.0‐g‐9.2.2.4‐pp‐dv‐s

user: oracle

ports:

‐ "7004:7004"

‐ "8004:8004"

‐ "8005:8005"

secrets:



environment:


networks:

jdenet:

aliases:

‐ jdeais


extra_hosts:

‐ "jdedep:10.0.0.5"

‐ "wlsadmin:127.0.0.1"

depends_on:

‐ jdeweb


volumes:


external: true

networks:

jdenet:

driver: bridge

ipam:

driver: default

config:

‐ subnet: 172.28.0.0/16

secrets:

jdedb_system_password:

file: ./secrets/jdedb_system_password.txt

wlsadmin_password:

file: ./secrets/wlsadmin_password.txt

File: OracleJDE/dockerfiles/run/exec-docker-compose-run-oc-s-9224.sh

#!/bin/bash

# This script sets the environment variables and executes docker‐compose‐run‐oc.yml

# RUN AS:

# ./exec‐docker‐compose‐run‐oc‐s.sh up

# ./exec‐docker‐compose‐run‐oc‐s.sh down

OPT=${1:‐"up ‐d"}

# dkrcmd sshtest root "yum ‐y install openssh‐clients"

dkrcmd()

{

DKR_SHELL="bash"

if [ "$1" = "jdeent" ]


then

DKR_SHELL="ksh"

fi

docker exec ‐u $2 $1 $DKR_SHELL ‐‐login ‐c "$3"

}

# export COMPOSE_HTTP_TIMEOUT=100

docker‐compose ‐f docker‐compose‐run‐oc‐s‐9224.yml $OPT

if [ "$OPT" = "up ‐d" ]

then

printf "\n\nChecking server status ...\n\n"

sleep 10


docker exec ‐u 0 jdeweb /bin/bash ‐c "echo \"$jdeent_ip jdeent\" >>/etc/hosts"

# jdeent_ip=$(docker exec jdeent cat /etc/hosts | grep ‐o '172.28.0.4')

# if [ "$jdeent_ip" != "172.28.0.4" ]

# then

# printf "\n\nJDE Enterprise Server IP is incorrect !!!\n\n"

# fi

# Fix DB /u01 permissions and restart agent

docker exec ‐u 0 jdedb chown ‐R oracle:dba /u01 > /dev/null 2>&1



sleep 20

printf "\n\nRunning port test on Enterprise Server\n\n"

docker exec ‐u jde920 jdeent bash ‐‐login ‐c "porttest JDE welc2jde DV920" | grep "Porttest

completed successfully"

if [ "$?" = "0" ]

then

printf "\n\nJDE Enterprise server is online\n\n"

fi

sleep 45

docker logs jdeweb | grep "The server 'JAS_server' is running now"

if [ "$?" = "0" ]

then

printf "\n\nJDE Web server is online\n\n"

fi


fi

File: OracleJDE/dockerfiles/run/scripts/jdeStartAisServ.sh

#!/bin/bash

#


#

export ADMIN_HOST=localhost

export ADMIN_PORT=7004

export WLS_BASE_DOMAIN=/u01/oracle/user_projects/domains/base_domain

# WLS_ADMIN_PASSWORD=$(cat /run/secrets/wlsadmin_password)

WLS_ADMIN_PASSWORD=$(cat /etc/secret‐volume/wlsadmin_password)

echo "Starting Management agent..."

/u01/jde_home/SCFHA/bin/stopAgent 2>&1 | tee ‐a /tmp/jde_mgmt_agent.log &

/u01/jde_home/SCFHA/bin/startAgent 2>&1 | tee ‐a /tmp/jde_mgmt_agent.log &

cd $WLS_BASE_DOMAIN

# Start AdminServer

echo "Starting AdminServer in background..."

nohup $WLS_BASE_DOMAIN/startWebLogic.sh 2>&1 | tee ‐a /tmp/jde_admin_server.log &

echo "Waiting for WebLogic Admin Server on $ADMIN_HOST:$ADMIN_PORT to become

available..."

while :

do

(echo > /dev/tcp/$ADMIN_HOST/$ADMIN_PORT) >/dev/null 2>&1

available=$?

if [[ $available ‐eq 0 ]]; then

echo "WebLogic Admin Server is now available. Proceeding..."

break

fi

sleep 1

done

# Start Node Manager


echo "Starting NodeManager in background..."

nohup $WLS_BASE_DOMAIN/bin/startNodeManager.sh 2>&1 | tee ‐a /tmp/jde_node_manager.log

&

sleep 10

# Start ManagedServer

echo "Starting ManagedServer in background..."

nohup $WLS_BASE_DOMAIN/bin/startManagedWebLogic.sh AIS_server

t3://$ADMIN_HOST:$ADMIN_PORT ‐Dweblogic.management.username=weblogic ‐

Dweblogic.management.password=$WLS_ADMIN_PASSWORD 2>&1 | tee ‐a

/tmp/jde_managed_server.log &

# print log

# the follow option ‐f keeps the stream open ensuring the container doesn't terminate

tail ‐f /tmp/jde_admin_server.log /tmp/jde_node_manager.log /tmp/jde_managed_server.log

/tmp/jde_mgmt_agent.log

File: OracleJDE/dockerfiles/run/scripts/jdeStartDB.sh

#!/bin/bash

#


#

echo "Starting Management agent in background..."



/opt/oracle/runOracle.sh 2>&1 | tee ‐a /tmp/jde_db.log &

tail ‐f /tmp/jde_mgmt_agent.log /tmp/jde_db.log

File: OracleJDE/dockerfiles/run/scripts/jdeStartEntServ.sh

#!/bin/bash

#


#


. /home/jde920/.profile

LOG="/tmp/jdeent.log"

AGENT_HOME="/u01/jde920/jde_home/SCFHA"

echo "EVRHOME: $EVRHOME" | tee ‐a $LOG

echo "SYSTEM: $SYSTEM" | tee ‐a $LOG

# DB_SYSTEM_PASSWORD=$(cat /run/secrets/jdedb_system_password)

DB_SYSTEM_PASSWORD=$(cat /etc/secret‐volume/jdedb_system_password)

echo "Starting Management agent..." | tee ‐a $LOG

$AGENT_HOME/bin/stopAgent 2>&1 | tee ‐a $LOG

$AGENT_HOME/bin/startAgent 2>&1 | tee ‐a $LOG

date | tee ‐a $LOG

flag=1

while [ $flag == 1 ]

do

echo "select 1 from dual;" | sqlplus ‐s system/$DB_SYSTEM_PASSWORD@JDEORCL 2>&1 >

/tmp/jde_db_check.log

cat /tmp/jde_db_check.log | grep ORA‐

if [ $? ‐ne 0 ]; then

date | tee ‐a $LOG

echo "jdedb is online" | tee ‐a $LOG

flag=0

else

echo "Waiting for jdedb to come online" | tee ‐a $LOG

sleep 20

fi

done

echo "Starting Enterprise Server..." | tee ‐a $LOG

$SYSTEM/bin32/RunOneWorld.sh 2>&1 | tee ‐a $LOG


tail ‐f $LOG /tmp/jde_db_check.log


File: OracleJDE/dockerfiles/run/scripts/jdeStartSMC.sh

#!/bin/bash

#


#

export WLS_BASE_DOMAIN=/u01/OracleSMC/user_projects/domains/jde_domain



cd $WLS_BASE_DOMAIN

# Start AdminServer




available..."

while :

do


available=$?



break

fi

sleep 1

done




&

# Start SMC

echo "Starting SMC in background..."

nohup $WLS_BASE_DOMAIN/bin/startManagedWebLogic.sh

SMC_Server_EOne_ManagementConsole1_Console http://$ADMIN_HOST:$ADMIN_PORT 2>&1 | tee ‐a

/tmp/jde_smc.log &


tail ‐f /tmp/jde_admin_server.log /tmp/jde_node_manager.log /tmp/jde_smc.log

File: OracleJDE/dockerfiles/run/scripts/jdeStartWebServ.sh

#!/bin/bash

#


#



export WLS_BASE_DOMAIN=/u01/oracle/user_projects/domains/base_domain

# WLS_ADMIN_PASSWORD=$(cat /run/secrets/wlsadmin_password)

WLS_ADMIN_PASSWORD=$(cat /etc/secret‐volume/wlsadmin_password)

echo "Starting Management agent..."



cd $WLS_BASE_DOMAIN

# Start AdminServer




available..."

while :

do


available=$?



break

fi

sleep 1

done





&

sleep 10

# Start ManagedServer

echo "Starting ManagedServer in background..."

nohup $WLS_BASE_DOMAIN/bin/startManagedWebLogic.sh JAS_server

t3://$ADMIN_HOST:$ADMIN_PORT ‐Dweblogic.management.username=weblogic ‐

Dweblogic.management.password=$WLS_ADMIN_PASSWORD 2>&1 | tee ‐a

/tmp/jde_managed_server.log &

# print log


tail ‐f /tmp/jde_admin_server.log /tmp/jde_node_manager.log /tmp/jde_managed_server.log

/tmp/jde_mgmt_agent.log

File: OracleJDE/dockerfiles/run/scripts/create-jdedb-data-volume.sh

#!/bin/bash

#


#


#


#

DB_DATA_ARCHIVE="jdedb‐9224‐ora12102‐pp‐data‐volume.tar.gz"

# docker volume rm jdedb‐9224‐ora12102‐pp‐data‐volume

printf "\n Creating volume \n\n"

docker volume create jdedb‐9224‐ora12102‐pp‐data‐volume

printf "\n Creating container jdedb \n\n"

docker run ‐d ‐‐name jdedb \

‐h jdedb \

‐v jdedb‐9224‐ora12102‐pp‐data‐volume:/opt/oracle/oradata/ \

oracle/jde/oradb:12.1.0.2‐se2‐9.2.2.4‐pp‐dv‐s \

bash ‐c "echo 'jde' > /tmp/jde.log; tail ‐f /tmp/jde.log"


printf "\n Extracting DB Data archive \n\n"

docker exec ‐u 0 jdedb bash ‐c "tar ‐P ‐C /opt/oracle/oradata/ ‐x ‐f /u01/$DB_DATA_ARCHIVE"

# docker exec ‐u 0 jdedb bash ‐c "cd /opt/oracle/oradata/_data && mv * .."

printf "\n Removing container jdedb \n\n"

docker stop jdedb && docker rm jdedb

Additional Steps

1. Copy the directory OracleWebLogic/samples/1221-domain/container-scripts to the following locations:

» OracleJDE/dockerfiles/build/oc_jdeais/container-scripts

» OracleJDE/dockerfiles/build/oc_jdeweb/container-scripts

2. Search and replace the following in all contents of OracleJDE/dockerfiles/build/oc_jdeais/container-scripts:

search: 7002, replace: 8004


3. Search and replace the following in all contents of OracleJDE/dockerfiles/build/oc_jdeweb/container-scripts:



Prerequisites

1. Provision a VM with the latest Oracle Linux version and install the latest version of Docker and docker-compose on the VM.

2. Provision a Windows 2012 Server R2 - Standard VM which will be used to deploy the JD Edwards EnterpriseOne Deployment Server.

3. Clone the oracle/docker-images repository at (https://github.com/oracle/docker-images) onto the provisioned Linux machine.

4. Copy the OracleJDE directory to the root folder where you have cloned the repository in step 3.

5. Download the JDE One-Click Provisioning archive to the Linux machine.

6. Copy the provided shell script to the home directory and add the following entry to ~/.bashrc

. ~/jde-helper-shell-functions.sh

7. Ensure the required ports are open (refer to docker-compose-deploy-oc.yml for the full list of ports).

8. Install the pre-requisites for Deployment server following the official documentation.

9. Set the Deployment server internal IP address in the following files by editing the line "jdedep:10.0.2.9".

a. docker-compose-deploy-oc.yml

b. docker-compose-run-oc-s-9224.yml


NOTE: IT IS STRONGLY RECOMMENDED THAT YOU USE A CLEAN LINUX VM FOR PROVISIONING SINCE THE PROVISIONING AND DB CONTAINERS WILL RUN WITH PRIVILEGED MODE ENABLED TO BE ABLE TO INSTALL THE REQUIRED JDE SERVICES.

Oracle Linux Host Pre-requisite Setup

Download the JD Edwards One-Click Provisioning archive

Download the files for JD Edwards EnterpriseOne One-Click Provisioning (REL: JD Edwards One-Click Provisioning

3.1 for Apps 9.2 Tools 9.2.2.4) from the Oracle Software Delivery Cloud.

From your download location, upload the files to any directory on the Linux VM.

Unzip each of the downloaded files using this command:

$ unzip '*.zip'

Assemble the unzipped images into a single archive using this command:

$ cat JDE_OCProv_9224_LINUX_18122_20GB.tgz.DiskPart0* > JDE_OCProv_9224_LINUX_18122_20GB.tgz

$ MD5CheckSUMFile=$(ls *MD5SUMS)

$ md5sum -c $MD5CheckSUMFile

$ rm JDE_OCProv_9224_LINUX_18122_20GB.tgz.DiskPart0*

Disable SELINUX

Edit the /etc/selinux/config file to change the SELINUX=setting to the following value and reboot the machine.

SELINUX=disabled

After reboot verify that SELINUX is disabled by executing the following command.

$ sudo getenforce

Disable the firewall

$ sudo -i

$ systemctl stop firewalld && systemctl disable firewalld

Windows VM hosts file entry

Add the following entries to C:\Windows\System32\drivers\etc\hosts. In the below example 10.0.2.6 is the internal IP

address of the Linux VM.

10.0.2.9 jdedep

10.0.2.6 jdedb

10.0.2.6 jdeprov

10.0.2.6 jdeent

10.0.2.6 jdeweb

10.0.2.6 jdeais


Build image Oracle DB Server 12.1.0.2 SE2

Download and place the following pre-requisite files in the "OracleDatabase/SingleInstance/dockerfiles/12.1.0.2"

directory. The binaries can be downloaded from the Oracle Technology Network.

» linuxamd64_12102_database_se2_1of2.zip

» linuxamd64_12102_database_se2_2of2.zip

Run the below commands to build the image:

$ cd OracleDatabase/SingleInstance/dockerfiles/

$ ./buildDockerImage.sh ‐v 12.1.0.2 –s

Build Image Oracle Java 8

Download and place the following pre-requisite files in the "OracleJava/java-8" directory. The binaries can be

downloaded from the Oracle Technology Network.

» server-jre-8u172-linux-x64.tar.gz


$ cd OracleJava/java‐8

$ ./build.sh

Build image Oracle WebLogic 12.2.1.0

Download and place the following pre-requisite files in the "OracleWebLogic/dockerfiles/12.2.1" directory. The

binaries can be downloaded from the Oracle Technology Network.

» fmw_12.2.1.0.0_wls_Disk1_1of1.zip


$ cd OracleWebLogic/dockerfiles

$ ./buildDockerImage.sh ‐v 12.2.1 –g

Generate the SSH keys in OpenSSH format

Generate a key pair and save the public key as docker_key.pub. You may use a tool like PuTTYgen to create the

key pair. The keys must not have a passphrase. Refer to documentation section titled “Generate Secure Shell (SSH)

Key Pairs on Your Local System” for more information.

Copy the public key docker_key.pub to directory "OracleJDE/dockerfiles/build/ssh_keys".

The private key will be specified in the JD Edwards One-Click Provisioning Console at a later step.

Build the JDE Base Images

$ cd OracleJDE/dockerfiles

$ ./build‐base‐images.sh


Deploy the JD Edwards EnterpriseOne Software Components Using the JD Edwards One-Click Provisioning Console

1. Create the Docker volumes.

$ docker volume create jdedb‐9224‐ora12102‐pp‐data‐volume

$ docker volume create jdeprov‐9224‐pp‐u01‐volume

Run the Docker base images.

$ cd OracleJDE/dockerfiles/

$ source ~/jde‐helper‐shell‐functions.sh

$ dkrcmpup

2. Start the DB server. Wait a few mins for the new database to be created.

$ dkrcmd jdedb oracle "/opt/oracle/runOracle.sh" 2>&1 | tee ‐a /tmp/jdedb.log &

Edit tnsnames.ora as follows.

$ dkrexec jdedb oracle

[oracle@jdedb admin]$ pwd

/opt/oracle/product/12.1.0.2/dbhome_1/network/admin

[oracle@jdedb admin]$ cat tnsnames.ora

JDEORCL=

(DESCRIPTION =

(ADDRESS = (PROTOCOL = TCP)(HOST = jdedb)(PORT = 1521))

(CONNECT_DATA =

(SERVER = DEDICATED)

(SERVICE_NAME = jdeorcl)

)

)

Note: Ensure that tnsnames.ora does not have the entry “orcl=localhost:1521/orcl”

3. Change the password and perform the pre-requisite steps.

$ dkrexec jdedb oracle

$ ./setPassword.sh <new‐password>

$ sqlplus '/as sysdba';

SELECT VALUE FROM NLS_DATABASE_PARAMETERS WHERE PARAMETER = 'NLS_CHARACTERSET';


‐‐> AL32UTF8

SELECT VALUE FROM NLS_DATABASE_PARAMETERS WHERE PARAMETER = 'NLS_NCHAR_CHARACTERSET';

‐‐> AL16UTF16

alter system set processes=1500 scope=spfile;

alter system set filesystemio_options=setall scope=spfile;

shutdown immediate;

startup;

4. Start the servers on the jdeweb and jdeais containers.

$ dkrcmd jdeweb oracle "./startWebLogic.sh" 2>&1 | tee ‐a /tmp/jdeweb.log &

$ dkrcmd jdeais oracle "./startWebLogic.sh" 2>&1 | tee ‐a /tmp/jdeais.log &

$ dkrcmd jdeweb oracle "/u01/oracle/createMachine.sh" 2>&1 | tee ‐a /tmp/jdeweb2.log &

$ dkrcmd jdeais oracle "/u01/oracle/createMachine.sh" 2>&1 | tee ‐a /tmp/jdeais2.log &

5. Copy the One-Click archive to the jdeprov container.

$ docker cp JDE_OCProv_9224_LINUX_18122_20GB.tgz jdeprov:/u01/

$ docker exec ‐u root jdeprov bash ‐c "chown opc:opc /u01/ JDE_OCProv_9224_LINUX_18122_20GB.tgz"

6. Login to the jdeprov container as root user and run the setup script.

$ docker exec ‐ti ‐u root jdeprov bash

$ cd /u01 && tar ‐P ‐C /u01 ‐x ‐f JDE_OCProv_9224_LINUX_18122_20GB.tgz

$ ./setupPr.sh

The Cloud UI will now be accessible at port 3000.

https://<public‐IP‐address>:3000/

You can now set the passwords and import the provided orchestration.json to deploy all the JD Edwards

EnterpriseOne servers.


Figure 24. JD Edwards One-Click Provisioning Console

7. Once the deployment is complete, login to SMC, Web and AIS Admin servers, uncheck “SSL Listen Port Enabled” and restart the servers.

8. Run the below command to correct the management agents to use non-SSL.

$ dkrfixagents

9. Commit the containers as new Docker images.

$ dkrcommit

$ docker images | grep "9.2.2.4‐pp‐dv" | grep "oracle/jde"

10. Stop the running containers.

$ dkrcmpdown

11. Save the Docker volumes which will be required to deploy the containers to other machines.

Sample commands are shown below.

sudo ‐i


MOUNT="/mnt/store"

BACKUPDIR="$MOUNT/data/prov_prime_9224"

DOCKERDIR="$MOUNT/docker"

DB_DATA_VOL="jdedb‐9224‐ora12102‐pp‐data‐volume"

PP_U01_VOL="jdeprov‐9224‐pp‐u01‐volume"

DB_DATA_VOL_DIR=$DOCKERDIR/volumes/$DB_DATA_VOL

PP_U01_VOL_DIR=$DOCKERDIR/volumes/$PP_U01_VOL

cd $DB_DATA_VOL_DIR

tar ‐P ‐cvzf $DB_DATA_VOL.tar.gz *

cd $PP_U01_VOL_DIR/_data

tar ‐P ‐cvzf $PP_U01_VOL‐smc.tar.gz app SMConsole E1CloudConsole OracleSMC CertGen jdk1.8.0 jde920

mkdir ‐p $BACKUPDIR

mv $DB_DATA_VOL_DIR/$DB_DATA_VOL.tar.gz $BACKUPDIR

mv $PP_U01_VOL_DIR/_data/$PP_U01_VOL‐smc.tar.gz $BACKUPDIR

chown ‐R opc:opc $BACKUPDIR

Build the JDE Final Images

In this step the start scripts for each container will be added to the container image. The DB Data archive will also be

copied to the DB server image to facilitate moving images from one machine to another.

Edit file "OracleJDE\dockerfiles\build-final-images.sh" and set the paths for DB_DATA_ARCHIVE and

JDEPROV_ARCHIVE.

Example:

DB_DATA_ARCHIVE="/mnt/store/data/prov_prime_9224/jdedb‐9224‐ora12102‐pp‐data‐volume‐orch.tar.gz"

JDEPROV_ARCHIVE="/mnt/store/data/prov_prime_9224/jdeprov‐9224‐pp‐u01‐volume‐smc.tar.gz"

Run the script to build the final images.

$ cd OracleJDE/dockerfiles

$ ./build‐final‐images.sh

Script create-jdedb-data-volume.sh is provided to re-create the DB data volume on the target machine. Set the

archive name in DB_DATA_ARCHIVE before executing the script on the target machine.

Run the JDE servers

1. Create files jdedb_system_password.txt and wlsadmin_password.txt in directory “OracleJDE/dockerfiles/run/secrets” containing the passwords of the DB system user and the WLS admin user (weblogic).


2. Run the Docker Compose file docker-compose-run-oc-s.yml using the wrapper script.

$ cd OracleJDE/dockerfiles/run

$ ./exec‐docker‐compose‐run‐oc‐s‐9224.sh

3. Wait a few minutes for the servers to start. The JDE servers will now be accessible at the following URLs:

» SMC: http://<public-IP-address>:8999/manage

» Web server: http://<public-IP-address>:8002/jde/E1Menu.maf

» AIS server: http://<public-IP-address>:8004/jderest/defaultconfig

To remove the containers run the command below.

$ ./exec‐docker‐compose‐run‐oc‐s‐9224.sh down

Sample Docker Compose File to Run JD Edwards EnterpriseOne in a Swarm

Run the below command to create the overlay network.

docker network create --driver=overlay --subnet=172.28.0.0/16 --ip-range=172.28.5.0/24

jdenet

Run the below command to deploy the stack.

docker stack deploy -c docker-compose.yml jdeapp

docker-compose.yml

version: "3.2"

services:

jdedb:

hostname: jdedb

image: oracle/jde/oradb:12.1.0.2‐se2‐9.2.2.4‐pp‐dv‐s

networks:

jdenet:

aliases:

‐ jdedb

volumes:


deploy:

restart_policy:

condition: on‐failure

endpoint_mode: dnsrr

placement:

constraints:

‐ node.labels.type == dbserver

environment:


ORACLE_SID: orcl

ORACLE_PDB: jdeorcl

ports:

‐ target: 1521

published: 1521

protocol: tcp

mode: host

jdeprov:

hostname: jdeprov

image: oracle/jde/prov:9.2.2.4‐pp‐dv‐s

environment:


ports:

‐ target: 8999

published: 8999

protocol: tcp

mode: host

‐ target: 7001

published: 7001

protocol: tcp

mode: host

‐ target: 14501

published: 14501

protocol: tcp

mode: host

deploy:

restart_policy:


placement:

constraints:

‐ node.labels.type2 == lb

networks:

jdenet:

aliases:

‐ jdeprov

jdeent:

hostname: jdeent

image: oracle/jde/ent:9.2.2.4‐pp‐dv‐s

deploy:

replicas: 1



restart_policy:


placement:

constraints:

‐ node.labels.type3 == jdeserver

networks:

jdenet:

aliases:

‐ jdeent

jdeweb:

hostname: jdeweb

image: oracle/jde/web:12.2.1.0‐g‐9.2.2.4‐pp‐dv‐s

deploy:

replicas: 1


restart_policy:


placement:

constraints:


extra_hosts:

‐ "jdeent:${HAPROXY_IP}"

networks:

jdenet:

aliases:

‐ jdeweb

jdeais:

hostname: jdeais

image: oracle/jde/ais:12.2.1.0‐g‐9.2.2.4‐pp‐dv‐s

deploy:

replicas: 1


restart_policy:


placement:

constraints:


extra_hosts:

‐ "jdeweb:${HAPROXY_IP}"


networks:

jdenet:

aliases:

‐ jdeais

networks:

jdenet:

external: true

volumes:


external: true

Conclusion

Containerizing JD Edwards EnterpriseOne servers provides greater flexibility and better utilization of available

resources, thus reducing infrastructure costs. It makes it easier to deploy highly available elastic environments that

can be updated with minimal downtime and without affecting connected users.

Oracle Corporation, World Headquarters Worldwide Inquiries

500 Oracle Parkway Phone: +1.650.506.7000

Redwood Shores, CA 94065, USA Fax: +1.650.506.7200

Copyright © 2018, Oracle and/or its affiliates. All rights reserved. This document is provided for information purposes only, and the contents hereof are subject to change without notice. This document is not warranted to be error-free, nor subject to any other warranties or conditions, whether expressed orally or implied in law, including implied warranties and conditions of merchantability or fitness for a particular purpose. We specifically disclaim any liability with respect to this document, and no contractual obligations are formed either directly or indirectly by this document. This document may not be reproduced or transmitted in any form or by any means, electronic or mechanical, for any purpose, without our prior written permission. Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners. Intel and Intel Xeon are trademarks or registered trademarks of Intel Corporation. All SPARC trademarks are used under license and are trademarks or registered trademarks of SPARC International, Inc. AMD, Opteron, the AMD logo, and the AMD Opteron logo are trademarks or registered trademarks of Advanced Micro Devices. UNIX is a registered trademark of The Open Group. 0718 Deploying Containerized JD Edwards EnterpriseOne on Oracle Cloud Infrastructure

C O N N E C T W I T H U S

blogs.oracle.com/oracle

facebook.com/oracle

twitter.com/oracle

oracle.com

based on docker containers - oracle.com · docker swarm is a cluster of docker engines. docker...

Documents