Deploying Containerized JD Edwards EnterpriseOne On Oracle Cloud Infrastructure
Uploaded by
Marcelo FernandezDeploying Containerized JD Edwards EnterpriseOne On Oracle Cloud Infrastructure
Uploaded by
Marcelo FernandezDeploying Containerized JD Edwards
EnterpriseOne on Oracle Cloud Infrastructure
Based on Docker Containers
ORACLE WHITE PAPER | JULY 2018
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.
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
0 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
1 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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.
1 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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.
2 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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.
3 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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.
4 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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.
5 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
6 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
» 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
7 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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.
8 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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:
9 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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.
10 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
11 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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:
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
server t1 jdeappv2_jdewebv2.1.xhwvcsja9k288xm2764dzucok:7003 maxconn 32 check cookie
frontend http-in-aissrv
bind *:7004
option httplog
option logasap
default_backend aisservers
12 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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.
13 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
14 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
frontend http-in-websrv
15 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
bind *:7003
option httplog
default_backend webservers
backend webservers
mode http
option httplog
balance roundrobin
cookie JSESSIONID prefix nocache
server s1 172.28.5.14:7003 maxconn 32 check cookie s1
server s2 172.28.5.13:7003 maxconn 32 check cookie s2
frontend http-in-aissrv
bind *:7004
option httplog
default_backend aisservers
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
16 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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`
17 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
18 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
BUILD_DIR=$2
WLSADMIN_PASS=$3
# ################## #
# 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 ‐‐build‐arg ADMIN_PASSWORD=$WLSADMIN_PASS . || {
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_copy_public_key()
{
cp $SSH_PUBLIC_KEY $1
}
cd ../..
ROOT_DIR=`pwd`
echo "Root directory: $ROOT_DIR"
cd $ROOT_DIR/OracleDatabase/SingleInstance/dockerfiles
19 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
#
# Author: [email protected]
#
# 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"
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"
20 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
}
# $1 ‐ file
# $2 ‐ target dir
jde_copy_file()
{
printf "\n Copying $1 to directory $2 \n"
cp $1 $2
21 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
}
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
22 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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"
restart: on‐failure
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:
23 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
jdenet:
aliases:
‐ jdeent
extra_hosts:
‐ "jdedep:10.0.0.3"
depends_on:
jdeprov:
condition: service_started
restart: on‐failure
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:
condition: service_started
restart: on‐failure
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:
‐ NM_HOST=localhost
24 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
networks:
jdenet:
aliases:
‐ jdeais
extra_hosts:
‐ "jdedep:10.0.0.3"
‐ "wlsadmin:127.0.0.1"
depends_on:
jdeweb:
condition: service_started
restart: on‐failure
# 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
#
# Author: [email protected]
# Description: Helper shell functions.
#
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
#
# Copyright (c) 2017‐2018 Oracle and/or its affiliates. All rights reserved.
#
25 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
# 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
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"
}
dkrcmpdown()
26 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
{
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"
27 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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/stopAgent"
dkrcmd jdedb oracle "/u01/jde_home/SCFHA/bin/startAgent"
dkrcmd jdeent jde920 "/u01/jde920/jde_home/SCFHA/bin/stopAgent"
dkrcmd jdeent jde920 "/u01/jde920/jde_home/SCFHA/bin/startAgent"
dkrcmd jdeweb oracle "/u01/jde_home/SCFHA/bin/stopAgent"
dkrcmd jdeweb oracle "/u01/jde_home/SCFHA/bin/startAgent"
dkrcmd jdeais oracle "/u01/jde_home/SCFHA/bin/stopAgent"
dkrcmd jdeais oracle "/u01/jde_home/SCFHA/bin/startAgent"
28 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
dkrcmd jdedb oracle "/opt/oracle/runOracle.sh" &
}
dkrstartagents()
{
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"
}
dkrstopagents()
{
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"
}
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"
29 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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",
"serviceType": "VM",
"hostDetails": {
"serviceName": "jdedb",
"osPlatform": "LINUX"
},
"serverDetails": {
"type": "ORACLE",
"adminPassword": "ACHCJKBHHCJKACMAEGJNFJPPFIDEPDPKLHJDBEKPCIKM",
"schemaPassword": "",
30 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
"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",
"serviceType": "VM",
"hostDetails": {
"serviceName": "jdeent",
"osPlatform": "LINUX"
},
"serverDetails": {
"dependentServer": "DB",
"pathcodes": [
"DEVELOPMENT"
],
"objType": [
"UBE",
"LOGIC"
]
}
}
],
"webServer": [
{
"instanceName": "JAS",
"serviceType": "VM",
"hostDetails": {
31 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
"serviceName": "jdeweb",
"osPlatform": "LINUX"
},
"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",
"serviceType": "VM",
"hostDetails": {
"serviceName": "jdeais",
"osPlatform": "LINUX"
},
"serverDetails": {
"instanceType": "aisServer",
"wlsUserName": "weblogic",
"wlsPassword": "ACHCJKDCHCJKLAIFBAGCCHMLIDIBFLDMPJNJOCCMPDPD",
"wlsAdminPort": "7004",
"wlsPath": "/u01/oracle",
"jdkPath": "/usr/java/jdk1.8.0_172",
"contentPort": "8004",
"securedContentPort": "8005",
"dependentServer": "JAS",
"enableClustering": false
}
}
],
"devClient": [],
"bipServer": []
}
32 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
File: OracleJDE/dockerfiles/orchestration_no_depsrv.json
{
"depServer": [],
"databaseServer": [
{
"instanceName": "DB",
"serviceType": "VM",
"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",
"serviceType": "VM",
"hostDetails": {
"serviceName": "jdeent",
"osPlatform": "LINUX"
},
"serverDetails": {
"dependentServer": "DB",
33 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
"pathcodes": [
"DEVELOPMENT"
],
"objType": [
"UBE",
"LOGIC"
]
}
}
],
"webServer": [
{
"instanceName": "JAS",
"serviceType": "VM",
"hostDetails": {
"serviceName": "jdeweb",
"osPlatform": "LINUX"
},
"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",
"serviceType": "VM",
"hostDetails": {
"serviceName": "jdeais",
"osPlatform": "LINUX"
},
"serverDetails": {
"instanceType": "aisServer",
"wlsUserName": "weblogic",
34 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
"wlsPassword": "ACHCJKDCHCJKLAIFBAGCCHMLIDIBFLDMPJNJOCCMPDPD",
"wlsAdminPort": "7004",
"wlsPath": "/u01/oracle",
"jdkPath": "/usr/java/jdk1.8.0_172",
"contentPort": "8004",
"securedContentPort": "8005",
"dependentServer": "JAS",
"enableClustering": false
}
}
],
"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
35 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
. ~/.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 && \
36 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
#
# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
#
# ORACLE DOCKERFILES PROJECT
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
# 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
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
37 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
# 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
# ‐‐‐‐‐‐‐‐‐‐
LABEL maintainer="Noel DCosta <[email protected]>"
# 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}" \
38 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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" >>
/u01/oracle/user_projects/domains/$DOMAIN_NAME/servers/AdminServer/security/boot.properties && \
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
ADD ./create‐opc‐user.sh /create‐opc‐user.sh
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
39 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
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_jdeent/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 Enterprise
Server software components.
#
# Pull base image
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
FROM oraclelinux:7
LABEL maintainer="Noel DCosta <[email protected]>"
ADD ./create‐opc‐user.sh /create‐opc‐user.sh
40 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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 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 && \
usermod ‐a ‐G oracle opc && \
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 \
sudo passwd vi telnet openssh‐server file which net‐tools; yum ‐y clean all
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_jdeprov/Dockerfile
41 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
# 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 Provisioning
Server.
#
# Pull base image
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
FROM oraclelinux:7
LABEL maintainer="Noel DCosta <[email protected]>"
ADD ./create‐opc‐user.sh /create‐opc‐user.sh
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 && \
usermod ‐a ‐G oracle opc && \
mkdir /u01 && chmod 770 /u01 && chown opc:oracle /u01
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
RUN gem install ‐v 1.8.1 ‐r winrm
# https://serverfault.com/questions/824975/failed‐to‐get‐d‐bus‐connection‐operation‐not‐permitted
42 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
# 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/
# 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.
#
# ORACLE DOCKERFILES PROJECT
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
# This Dockerfile extends the Oracle WebLogic image by creating a sample domain.
#
43 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
# 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
# ‐‐‐‐‐‐‐‐‐‐
LABEL maintainer="Noel DCosta <[email protected]>"
# 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}" \
44 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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" >>
/u01/oracle/user_projects/domains/$DOMAIN_NAME/servers/AdminServer/security/boot.properties && \
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
ADD ./create‐opc‐user.sh /create‐opc‐user.sh
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 \
45 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
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/final_jdeais/Dockerfile
# LICENSE CDDL 1.0 + GPL 2.0
#
# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
#
# ORACLE DOCKERFILES PROJECT
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
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" \
46 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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|JasProtocol=.*|JasProtocol=http|g' ${REST_INI2} && \
sed ‐i ‐e 's|JasProtocol=.*|JasProtocol=http|g' ${REST_INI3} && \
sed ‐i ‐e 's|JasPort=.*|JasPort=8002|g' ${REST_INI1} && \
sed ‐i ‐e 's|JasPort=.*|JasPort=8002|g' ${REST_INI2} && \
sed ‐i ‐e 's|JasPort=.*|JasPort=8002|g' ${REST_INI3} && \
sed ‐i ‐e 's|SecurityServer=.*|SecurityServer=jdeent|g' ${REST_INI1} && \
sed ‐i ‐e 's|SecurityServer=.*|SecurityServer=jdeent|g' ${REST_INI2} && \
sed ‐i ‐e 's|SecurityServer=.*|SecurityServer=jdeent|g' ${REST_INI3} && \
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'
${MGMT_AGENT_HOME}/config/agent.properties && \
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
# LICENSE CDDL 1.0 + GPL 2.0
#
# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
#
# ORACLE DOCKERFILES PROJECT
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
47 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
FROM oracle/jde/oradb:12.1.0.2‐se2‐9.2.2.4‐pp‐dv
ENV MGMT_AGENT_HOME="/u01/jde_home/SCFHA" \
DB_DATA_ARCHIVE="jdedb‐9224‐ora12102‐pp‐data‐volume.tar.gz"
ADD jdeStartDB.sh /scripts/jdeStartDB.sh
USER root
RUN chown ‐R oracle:oracle /scripts/ && chmod 755 /scripts/*.sh && \
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'
${MGMT_AGENT_HOME}/config/agent.properties && \
rm ‐f ${MGMT_AGENT_HOME}/agent.pid && \
rm ‐f ${MGMT_AGENT_HOME}/logs/*.log*
# RUN chown ‐R oracle:dba /u01/
COPY ${DB_DATA_ARCHIVE} /u01/
USER oracle
CMD /scripts/jdeStartDB.sh
File: OracleJDE/dockerfiles/build/final_jdeent/Dockerfile
# LICENSE CDDL 1.0 + GPL 2.0
#
# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
#
# ORACLE DOCKERFILES PROJECT
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
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
48 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
&& \
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'
${MGMT_AGENT_HOME}/config/agent.properties && \
rm ‐f ${MGMT_AGENT_HOME}/agent.pid && \
rm ‐f ${MGMT_AGENT_HOME}/logs/*.log*
USER jde920
WORKDIR /u01/jde920/e920
CMD /scripts/jdeStartEntServ.sh
File: OracleJDE/dockerfiles/build/final_jdeprov/Dockerfile
# LICENSE CDDL 1.0 + GPL 2.0
#
# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
#
# ORACLE DOCKERFILES PROJECT
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
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
49 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
File: OracleJDE/dockerfiles/build/final_jdeweb/Dockerfile
# LICENSE CDDL 1.0 + GPL 2.0
#
# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
#
# ORACLE DOCKERFILES PROJECT
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
FROM oracle/jde/web:12.2.1.0‐g‐9.2.2.4‐pp‐dv
ENV MGMT_AGENT_HOME="/u01/jde_home/SCFHA" \
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
RUN chown ‐R oracle:oracle /scripts/ && chmod 755 /scripts/*.sh && \
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|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'
${MGMT_AGENT_HOME}/config/agent.properties && \
sed ‐i ‐e 's|AISProtocol=.*|AISProtocol=http|g' ${JAS_INI1} && \
sed ‐i ‐e 's|AISProtocol=.*|AISProtocol=http|g' ${JAS_INI2} && \
sed ‐i ‐e 's|AISProtocol=.*|AISProtocol=http|g' ${JAS_INI3} && \
sed ‐i ‐e 's|AISPort=.*|AISPort=8004|g' ${JAS_INI1} && \
sed ‐i ‐e 's|AISPort=.*|AISPort=8004|g' ${JAS_INI2} && \
sed ‐i ‐e 's|AISPort=.*|AISPort=8004|g' ${JAS_INI3} && \
rm ‐f ${MGMT_AGENT_HOME}/agent.pid && \
rm ‐f ${MGMT_AGENT_HOME}/logs/*.log*
50 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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:
‐ jdedb‐9224‐ora12102‐pp‐data‐volume:/opt/oracle/oradata/
networks:
jdenet:
aliases:
‐ jdedb
extra_hosts:
‐ "jdedep:10.0.0.5"
environment:
ORACLE_SID: orcl
ORACLE_PDB: jdeorcl
restart: on‐failure
jdeprov:
hostname: jdeprov
container_name: jdeprov
image: oracle/jde/prov:9.2.2.4‐pp‐dv‐s
user: oracle
ports:
‐ "3000:3000"
51 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
‐ "8999:8999"
‐ "8998:8998"
‐ "7001:7001"
‐ "14501:14501"
‐ "14502:14502"
secrets:
‐ source: jdedb_system_password
target: /etc/secret‐volume/jdedb_system_password
‐ source: wlsadmin_password
target: /etc/secret‐volume/wlsadmin_password
networks:
jdenet:
aliases:
‐ jdeprov
extra_hosts:
‐ "jdedep:10.0.0.5"
restart: on‐failure
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:
‐ source: jdedb_system_password
target: /etc/secret‐volume/jdedb_system_password
networks:
jdenet:
aliases:
‐ jdeent
extra_hosts:
‐ "jdedep:10.0.0.5"
depends_on:
‐ jdeprov
restart: on‐failure
jdeweb:
hostname: jdeweb
52 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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:
‐ source: wlsadmin_password
target: /etc/secret‐volume/wlsadmin_password
environment:
‐ NM_HOST=localhost
networks:
jdenet:
aliases:
‐ jdeweb
extra_hosts:
‐ "jdedep:10.0.0.5"
‐ "jdeent:172.28.0.4"
‐ "wlsadmin:127.0.0.1"
depends_on:
‐ jdeent
restart: on‐failure
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:
‐ source: wlsadmin_password
target: /etc/secret‐volume/wlsadmin_password
environment:
‐ NM_HOST=localhost
networks:
jdenet:
aliases:
‐ jdeais
53 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
extra_hosts:
‐ "jdedep:10.0.0.5"
‐ "wlsadmin:127.0.0.1"
depends_on:
‐ jdeweb
restart: on‐failure
volumes:
jdedb‐9224‐ora12102‐pp‐data‐volume:
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" ]
54 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
jdeent_ip=$(docker exec jdeent cat /etc/hosts | grep ‐o '172.28.0.[0‐9]\{1,3\}')
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
dkrcmd jdedb oracle "/u01/jde_home/SCFHA/bin/stopAgent"
dkrcmd jdedb oracle "/u01/jde_home/SCFHA/bin/startAgent"
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
55 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
fi
File: OracleJDE/dockerfiles/run/scripts/jdeStartAisServ.sh
#!/bin/bash
#
# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
#
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
56 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
#
# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
#
echo "Starting Management agent in background..."
/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 &
/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
#
# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
#
57 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
. /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
# the follow option ‐f keeps the stream open ensuring the container doesn't terminate
tail ‐f $LOG /tmp/jde_db_check.log
58 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
File: OracleJDE/dockerfiles/run/scripts/jdeStartSMC.sh
#!/bin/bash
#
# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
#
export WLS_BASE_DOMAIN=/u01/OracleSMC/user_projects/domains/jde_domain
export ADMIN_HOST=localhost
export ADMIN_PORT=7001
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
&
# 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 &
59 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
#
# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
#
export ADMIN_HOST=localhost
export ADMIN_PORT=7002
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..."
60 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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 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
# 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/create-jdedb-data-volume.sh
#!/bin/bash
#
# Author: [email protected]
#
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
#
# Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
#
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"
61 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
search: 7001, replace: 7004
3. Search and replace the following in all contents of OracleJDE/dockerfiles/build/oc_jdeweb/container-
scripts:
search: 7002, replace: 8002
search: 7001, replace: 7002
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
62 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
63 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
Run the below commands to build the image:
$ 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
Run the below commands to build the image:
$ 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
64 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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';
65 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
‐‐> 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.
66 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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
67 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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).
68 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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:
‐ jdedb‐9224‐ora12102‐pp‐data‐volume:/opt/oracle/oradata/
deploy:
restart_policy:
condition: on‐failure
endpoint_mode: dnsrr
placement:
constraints:
‐ node.labels.type == dbserver
environment:
69 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
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:
‐ NM_HOST=localhost
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:
condition: on‐failure
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
70 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
endpoint_mode: dnsrr
restart_policy:
condition: on‐failure
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
endpoint_mode: dnsrr
restart_policy:
condition: on‐failure
placement:
constraints:
‐ node.labels.type3 == jdeserver
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
endpoint_mode: dnsrr
restart_policy:
condition: on‐failure
placement:
constraints:
‐ node.labels.type3 == jdeserver
extra_hosts:
‐ "jdeweb:${HAPROXY_IP}"
71 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
networks:
jdenet:
aliases:
‐ jdeais
networks:
jdenet:
external: true
volumes:
jdedb‐9224‐ora12102‐pp‐data‐volume:
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.
72 | DEPLOYING CONTAINERIZED JD EDWARDS ENTERPRISEONE ON ORACLE CLOUD INFRASTRUCTURE
Oracle Corporation, World Headquarters Worldwide Inquiries
500 Oracle Parkway Phone: +1.650.506.7000
Redwood Shores, CA 94065, USA Fax: +1.650.506.7200
CONNECT WITH US
blogs.oracle.com/oracle
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
facebook.com/oracle 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
twitter.com/oracle means, electronic or mechanical, for any purpose, without our prior written permission.
oracle.com 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
You might also like
- Vu Player Pro - Free Download and Install On Windows - Microsoft StoreNo ratings yetVu Player Pro - Free Download and Install On Windows - Microsoft Store6 pages
- I Get To Love You Ruelle Sheet Music For Piano, Violin (Mixed Duet)No ratings yetI Get To Love You Ruelle Sheet Music For Piano, Violin (Mixed Duet)1 page
- Oracle Fusion Middleware Administration: Atul KumarNo ratings yetOracle Fusion Middleware Administration: Atul Kumar27 pages
- Oracle WebLogic Server Deployment GuideNo ratings yetOracle WebLogic Server Deployment Guide20 pages
- Ricoh Us Im c300f, Im c400f, Im C400srf-Sales Presentation-D5No ratings yetRicoh Us Im c300f, Im c400f, Im C400srf-Sales Presentation-D568 pages
- HPE A00004043en Us HPE StoreVirtual Management Console User GuideNo ratings yetHPE A00004043en Us HPE StoreVirtual Management Console User Guide140 pages
- Google Certified Professional Cloud Architect - Part 1: Course FeaturesNo ratings yetGoogle Certified Professional Cloud Architect - Part 1: Course Features9 pages
- 50 Excel Shortcuts To Save Time and Effort in ArticleshipNo ratings yet50 Excel Shortcuts To Save Time and Effort in Articleship9 pages
- Oracle Fusion Middleware Administration: Atul KumarNo ratings yetOracle Fusion Middleware Administration: Atul Kumar26 pages
- Walchand Institute of Technology, Solapur: Direct Linking LoadersNo ratings yetWalchand Institute of Technology, Solapur: Direct Linking Loaders14 pages
- Acronis #CyberFit Cloud Tech Associate Advanced Files and Notary 2022No ratings yetAcronis #CyberFit Cloud Tech Associate Advanced Files and Notary 2022189 pages
- VRealize Operations Manager Installation and Configuration Guide For Linux and WindowsNo ratings yetVRealize Operations Manager Installation and Configuration Guide For Linux and Windows98 pages
- Automated Number Plate Recognition & BeyondNo ratings yetAutomated Number Plate Recognition & Beyond1 page
- HPE - A00127319en - Us - HPE Performance Cluster Manager Upgrade GuideNo ratings yetHPE - A00127319en - Us - HPE Performance Cluster Manager Upgrade Guide42 pages
- PUE 3123 - Telecommunication Network Design and Planning - 06100% (1)PUE 3123 - Telecommunication Network Design and Planning - 0655 pages
- Configuring and Managing Backups: This Lab Contains The Following Exercises and ActivitiesNo ratings yetConfiguring and Managing Backups: This Lab Contains The Following Exercises and Activities11 pages
- Empowering Your Retail Frontline Workers Presentation DeckNo ratings yetEmpowering Your Retail Frontline Workers Presentation Deck28 pages
- Motor Forward and Reverse Direction Control Using A PLCNo ratings yetMotor Forward and Reverse Direction Control Using A PLC5 pages
- ONTAP Select Performance Characterization ToolNo ratings yetONTAP Select Performance Characterization Tool23 pages
- RMAN Backups in A RAC Environment: Edward Whalen Performance Tuning CorporationNo ratings yetRMAN Backups in A RAC Environment: Edward Whalen Performance Tuning Corporation68 pages
- Cloud Train DevOps Instructor Led Training Curriculum 2023No ratings yetCloud Train DevOps Instructor Led Training Curriculum 202325 pages
- Smart Logistics Based On The Internet of Things TechnologyNo ratings yetSmart Logistics Based On The Internet of Things Technology24 pages
- VSE+InfoScale Enterprise OracleRAC 2020 05No ratings yetVSE+InfoScale Enterprise OracleRAC 2020 0589 pages
- Oracle Enterprise Manager 12c Agent Installation GuideNo ratings yetOracle Enterprise Manager 12c Agent Installation Guide39 pages
- Managing Failover Clustering: This Lab Contains The Following Exercises and ActivitiesNo ratings yetManaging Failover Clustering: This Lab Contains The Following Exercises and Activities11 pages
- Extending and Multi Rack Cabling Guide Engineered Systems DBMMRNo ratings yetExtending and Multi Rack Cabling Guide Engineered Systems DBMMR212 pages
- OpenShift Container Platform-4.6-Installing On OpenStack-en-USNo ratings yetOpenShift Container Platform-4.6-Installing On OpenStack-en-US178 pages
- Aws Solution Architect Associate Course AgendaNo ratings yetAws Solution Architect Associate Course Agenda9 pages
- Speed Control and Direction Control of DC Motor Using Arm7: K.A.Wadile, S.R.Chillarge, D.D.JadhavNo ratings yetSpeed Control and Direction Control of DC Motor Using Arm7: K.A.Wadile, S.R.Chillarge, D.D.Jadhav5 pages
- Red Hat Enterprise Linux 9 Migrating To Identity Management On Rhel 9No ratings yetRed Hat Enterprise Linux 9 Migrating To Identity Management On Rhel 940 pages
- EBSPROD - Switchover - Switchback - Version 1.0No ratings yetEBSPROD - Switchover - Switchback - Version 1.020 pages
- Introduction To Oracle Fusion and Application Development FrameworkNo ratings yetIntroduction To Oracle Fusion and Application Development Framework10 pages
- OpenStack Quantum SDN With Open Vswitch PDFNo ratings yetOpenStack Quantum SDN With Open Vswitch PDF20 pages
- Upgrading Satellite and Capsule From RHEL 7 To RHEL 8 - HackMDNo ratings yetUpgrading Satellite and Capsule From RHEL 7 To RHEL 8 - HackMD22 pages
- Product - Middleware - Oracle SOA Suite 12c - System Architecture and Administration100% (1)Product - Middleware - Oracle SOA Suite 12c - System Architecture and Administration12 pages
- OpenShift Container Platform 3.5 Administrator Solutions en USNo ratings yetOpenShift Container Platform 3.5 Administrator Solutions en US55 pages
- Proxmox VE-Subscription-Agreement V3.0 PDFNo ratings yetProxmox VE-Subscription-Agreement V3.0 PDF4 pages
