info icon

Introduction

Universal Base Image (UBI) consists of enterprise-ready and OCI-compliant Linux containers that offer greater security with stricter defaults than general images.

For more information, see Red Hat’s Universal Base Image and Red Hat Universal base image how it works

Some of the base images require authentication with the RedHat Container Registry. You must be logged in to the following registries:

registry.redhat.io
- For accessing registry.redhat.io/rhel8/httpd-24
- Login using docker login registry.redhat.io
registry.connect.redhat.com
- For accessing registry.connect.redhat.com/ibm/ibmjava8-sdk-ubi8-minimal
- Login using docker login registry.connect.redhat.com

Note: As covered in building Base images, if you do not have an active RedHat subscription you will need to build your own base images from source following the steps there.

Should you opt to build your own base images, the BASE_REGISTRY argument in the following commands may be omitted, if the base images are built in the same environment.

If the images are stored in a private registry, set BASE_REGISTRY to the registry’s hostname.

For the docker commands that follow you must set a DOCKER_REGISTRY environment variable based on the container environment you are deploying:

The URL for this value can be retrieved using this command: oc registry info --public

For example:

export DOCKER_REGISTRY=default-route-openshift-image-registry.apps-crc.testing
Copy to clipboard

export DOCKER_REGISTRY=minikube.local:5000
Copy to clipboard

IMPORTANT: For Minikube on Windows set DOCKER_REGISTRY to the value: localhost:5000. See the Minikube Handbook for more information.

`$env:DOCKER_REGISTRY = "localhost:5000"`
Copy to clipboard

export DOCKER_REGISTRY=us.icr.io
Copy to clipboard

Now that all the elements are in place, build the images as follows:

Building the images

The following sections provide steps for building the Docker images.

Set the PROJECT environment variable:

Note: In the following commands, the value of $PROJECT will change depending on deployment type:

For a Minikube deployment the value of $PROJECT is arbitrary.
For an AKS deployment the value of $PROJECT must equate to a valid namespace in the customer’s account.
For an OpenShift deployment the value of $PROJECT must equate to a valid project. For this runbook it is best to stick with the value chosen for $PROJECT in Creating a CRC project

XML server image

To build the XML server image, run the following commands:

cd $SPM_HOME/dockerfiles/Liberty/
docker build \
     --tag $DOCKER_REGISTRY/$PROJECT/xmlserver:latest \
     --build-arg "BASE_REGISTRY=registry.connect.redhat.com/" \
     --file XMLServer.Dockerfile .
Copy to clipboard

cd $SPM_HOME/dockerfiles/Liberty/
docker build \
     --tag $DOCKER_REGISTRY/$PROJECT/xmlserver:latest \
     --file XMLServer.Dockerfile .
Copy to clipboard

cd $SPM_HOME/dockerfiles/Liberty/
docker build `
     --tag $env:DOCKER_REGISTRY/$env:PROJECT/xmlserver:latest `
     --build-arg "BASE_REGISTRY=registry.connect.redhat.com/" `
     --file XMLServer.Dockerfile .
Copy to clipboard

cd $env:SPM_HOME\dockerfiles\Liberty\
docker build --tag $env:DOCKER_REGISTRY/$env:PROJECT/xmlserver:latest `
     --file XMLServer.Dockerfile .
Copy to clipboard

For information on building an XML server sidecar performance monitoring image see Monitoring XML servers.

Utilities image

The utilities image is used at various stages of the deployment to check the state of the deployment.

To build the utilities image, run the following commands:

cd $SPM_HOME/dockerfiles/Liberty/
docker build \
     --tag $DOCKER_REGISTRY/$PROJECT/utilities:latest \
     --build-arg "BASE_REGISTRY=registry.connect.redhat.com/" \
     --file Utilities.Dockerfile .
Copy to clipboard

cd $SPM_HOME/dockerfiles/Liberty/
docker build \
     --tag $DOCKER_REGISTRY/$PROJECT/utilities:latest \
     --file Utilities.Dockerfile .
Copy to clipboard

cd $env:SPM_HOME\dockerfiles\Liberty\
docker build `
     --tag $env:DOCKER_REGISTRY/$env:PROJECT/utilities:latest `
     --build-arg "BASE_REGISTRY=registry.connect.redhat.com/" `
     --file Utilities.Dockerfile .
Copy to clipboard

cd $env:SPM_HOME\dockerfiles\Liberty\
docker build --tag $env:DOCKER_REGISTRY/$env:PROJECT/utilities:latest `
       --file Utilities.Dockerfile .
Copy to clipboard

Batch image

A .dockerignore file is used to omit the EAR files from the build context for batch.

To build the batch image, run the following commands:

cd $SPM_HOME/dockerfiles/Liberty/
echo -e 'content/release-stage/ear' > .dockerignore
docker build \
     --tag $DOCKER_REGISTRY/$PROJECT/batch:latest \
     --file Batch.Dockerfile .
rm -f .dockerignore
Copy to clipboard

cd $env:SPM_HOME\dockerfiles\Liberty\
echo "content/release-stage/ear" | set-content .dockerignore -Encoding Ascii
docker build `
     --tag $env:DOCKER_REGISTRY/$env:PROJECT/batch:latest `
     --file Batch.Dockerfile .
del  .dockerignore
Copy to clipboard

Server Code image

To build the Server Code image, run the following commands:

cd $SPM_HOME/dockerfiles/Liberty/
docker build \
     --tag $DOCKER_REGISTRY/$PROJECT/servercode:latest \
     --file ServerEAR.Dockerfile \
     --build-arg "MQ_RA_LICENSE=--acceptLicense" .
Copy to clipboard

cd $env:SPM_HOME\dockerfiles\Liberty\
docker build `
     --tag $env:DOCKER_REGISTRY/$env:PROJECT/servercode:latest `
     --file ServerEAR.Dockerfile `
     --build-arg "MQ_RA_LICENSE=--acceptLicense" .
Copy to clipboard

Application images

Take note of the SERVERCODE_IMAGE build argument which references the server code image - this gives the images a common base.

To build the application images, run the following commands for each of the applications (EAR files) needed:

cd $SPM_HOME/dockerfiles/Liberty/
docker build \
     --tag $DOCKER_REGISTRY/$PROJECT/curam:latest \
     --file ClientEAR.Dockerfile \
     --build-arg "SERVERCODE_IMAGE=$DOCKER_REGISTRY/$PROJECT/servercode:latest" \
     --build-arg "EAR_NAME=Curam" .
Copy to clipboard

cd $env:SPM_HOME\dockerfiles\Liberty\
docker build `
     --tag $env:DOCKER_REGISTRY/$env:PROJECT/curam:latest `
     --file ClientEAR.Dockerfile \
     --build-arg "SERVERCODE_IMAGE=$env:DOCKER_REGISTRY/$env:PROJECT/servercode:latest" \
     --build-arg "EAR_NAME=Curam" .
Copy to clipboard

For additional SPM applications (e.g. Rest, CitizenPortal), make the following changes to the command:

the value of the --tag argument must be the application name in lowercase
the value of the --build-arg EAR_NAME argument must be the name of the EAR file without the file extension (that is, for Rest.ear, use the value Rest)

docker build \
     --tag $DOCKER_REGISTRY/$PROJECT/rest:latest \
     --file ClientEAR.Dockerfile \
     --build-arg "SERVERCODE_IMAGE=$DOCKER_REGISTRY/$PROJECT/servercode:latest" \
     --build-arg "EAR_NAME=Rest" .
Copy to clipboard

For additional SPM applications (e.g. Rest, CitizenPortal), make the following changes to the command:

the value of the --tag argument must be the application name in lowercase
the value of the --build-arg EAR_NAME argument must be the name of the EAR file without the file extension (that is, for Rest.ear, use the value Rest)

docker build `
     --tag $env:DOCKER_REGISTRY/$env:PROJECT/rest:latest `
     --file ClientEAR.Dockerfile `
     --build-arg "SERVERCODE_IMAGE=$env:DOCKER_REGISTRY/$env:PROJECT/servercode:latest" `
     --build-arg "EAR_NAME=Rest" .
Copy to clipboard

Static Content image

To build the static content image, run the following commands:

cd $SPM_HOME/dockerfiles/HTTPServer/
docker build \
     --tag $DOCKER_REGISTRY/$PROJECT/httpd:latest \
     --file StaticContent.Dockerfile \
     --build-arg "BASE_REGISTRY=registry.redhat.io/" \
     --build-arg "CONTENT_DIR=/CuramStatic" .
Copy to clipboard

cd $SPM_HOME/dockerfiles/HTTPServer/
docker build \
     --tag $DOCKER_REGISTRY/$PROJECT/httpd:latest \
     --file StaticContent.Dockerfile \
     --build-arg "CONTENT_DIR=/CuramStatic" .
Copy to clipboard

cd $env:SPM_HOME\dockerfiles\HTTPServer\
docker build `
     --tag $env:DOCKER_REGISTRY/$env:PROJECT/httpd:latest `
     --file StaticContent.Dockerfile `
     --build-arg "BASE_REGISTRY=registry.redhat.io/" `
     --build-arg "CONTENT_DIR=/CuramStatic" .
Copy to clipboard

cd $env:SPM_HOME\dockerfiles\HTTPServer\
docker build `
     --tag $env:DOCKER_REGISTRY/$env:PROJECT/httpd:latest `
     --file StaticContent.Dockerfile `
     --build-arg "CONTENT_DIR=/CuramStatic" .
Copy to clipboard

Note: The CONTENT_DIR build argument must correspond to the value set in curam-config.xml when the webclient was built.

Universal Access image

To build an SPM Docker image for your built Universal Access application:

Copy the build directory from the React application to $SPM_HOME/dockerfiles/HTTPServer
Run the following commands:

This is applicable only if you are licensed for SPM Universal Access.

Note: The CONTENT_DIR build argument must correspond to the value of the PUBLIC_URL variable set when creating the production build of the React app (npm run build).

cd $SPM_HOME/dockerfiles/HTTPServer/
docker build \
     --tag $DOCKER_REGISTRY/$PROJECT/uawebapp:latest \
     --file UAWebApp.Dockerfile \
     --build-arg "BASE_REGISTRY=registry.redhat.io/" \
     --build-arg "CONTENT_DIR=/universal" .
Copy to clipboard

cd $SPM_HOME/dockerfiles/HTTPServer/
docker build \
     --tag $DOCKER_REGISTRY/$PROJECT/uawebapp:latest \
     --file UAWebApp.Dockerfile \
     --build-arg "CONTENT_DIR=/universal" .
Copy to clipboard

cd $env:SPM_HOME\dockerfiles\HTTPServer\
docker build `
     --tag $env:DOCKER_REGISTRY/$env:PROJECT/uawebapp:latest `
     --file UAWebApp.Dockerfile `
     --build-arg "BASE_REGISTRY=registry.redhat.io/" `
     --build-arg "CONTENT_DIR=/universal" .
Copy to clipboard

cd $env:SPM_HOME\dockerfiles\HTTPServer\
docker build `
     --tag $env:DOCKER_REGISTRY/$env:PROJECT/uawebapp:latest `
     --file UAWebApp.Dockerfile `
     --build-arg "CONTENT_DIR=/universal" .
Copy to clipboard

Pushing the images to the registry

When you set up Minikube by following the steps in Minikube, a registry was also created to store the Docker images. To push the new images that you created to the registry, run the following commands:

docker push $DOCKER_REGISTRY/$PROJECT/xmlserver:latest
docker push $DOCKER_REGISTRY/$PROJECT/utilities:latest
docker push $DOCKER_REGISTRY/$PROJECT/batch:latest
docker push $DOCKER_REGISTRY/$PROJECT/servercode:latest
docker push $DOCKER_REGISTRY/$PROJECT/curam:latest
docker push $DOCKER_REGISTRY/$PROJECT/httpd:latest
Copy to clipboard

If any additional images were built (for other SPM applications or for the React application), do not forget to push the images too. For example:

docker push $DOCKER_REGISTRY/$PROJECT/rest:latest
docker push $DOCKER_REGISTRY/$PROJECT/uawebapp:latest
Copy to clipboard

Pushing the images to the a Container Registry

A Container Registry is the service to distribute the containers across a Kubernetes service In order to configure it, some preparation steps are required to obtain the credentials and a namespace, globally unique between all the tenants of your cloud of choice. Refer to Getting Started with Artifactory as a Docker Registry for more information on configuring the registry and obtaining the required credentials.

docker login ${server-name}.jfrog.io


docker push ${server-name}.jfrog.io/{repo-name}/xmlserver:latest
docker push ${server-name}.jfrog.io/{repo-name}/utilities:latest
docker push ${server-name}.jfrog.io/{repo-name}/batch:latest
docker push ${server-name}.jfrog.io/{repo-name}/curam:latest
docker push ${server-name}.jfrog.io/{repo-name}/httpd:latest
Copy to clipboard

View the artifacts in the repository

Confirm that the pushes to the Docker registry succeeded. Run the following command:

curl http://$DOCKER_REGISTRY/v2/_catalog
Copy to clipboard

curl -k -ukubeadmin:$(oc whoami -t) https://$(oc registry info --public)/v2/_catalog
Copy to clipboard

The command returns the following result, depending on the images built and your tagging:

{"repositories":["batch","curam","xmlserver","httpd","utilities", "servercode"]}
Copy to clipboard

Note: Due to an issue with Minikube you will need to repush the Docker images to the registry each time you shut down.

For more information about the Docker Registry HTTP API, see Docker Registry HTTP API V2.

Building Docker images: Building base images

Deploying with Helm Charts: Preparing Helm Charts

Building the Docker® images