Alternative container construction samples, using buildah/podman + RH UBI base images

ibmmqmet · ibmmqmet · commit 0a39c038c9db · 2021-09-08T09:13:05.000+01:00
diff --git a/samples/README.md b/samples/README.md
@@ -39,9 +39,13 @@ Some trivial scripts run the sample programs in matching pairs:
 * pubsub.sh  : Start amqssub and then run the amqspub program immediately
 
 Building a container:
-* runSample.sh         : Drives the process to get `amqsput` into the container
-* runSample.Dockerfile : Instructions to create the container with its dependencies
-* runSample.gomod      : Copied into the container as `go.mod`
+* runSample.sh           : Drives the process to get `amqsput` into the container
+* runSample.bud.sh       : Drives the process to get `amqsput` into the container using podman/buildah as an alternative approach
+* runSample.*.Dockerfile : Instructions to create containers with runtime dependencies
+* runSample.gomod        : Copied into the container as `go.mod`
+Two variants of the Dockerfile are provided. Set the `FROM` environment variable to "UBI"
+to use Red Hat Universal Base Images as the starting points for building and runtime;
+otherwise an Ubuntu/Debian combination is used.
 
 The `mqitest` sample program in its own subdirectory is a more general demonstration
 of many of the features available from the MQI rather than focussed on a specific
@@ -64,7 +68,7 @@ For example
   go run amqsput.go DEV.QUEUE.1 QM1
 ```
 
-The amqsput.go program also allows the queue and queue manager names to 
+The amqsput.go program also allows the queue and queue manager names to
 be provided by environment variables, to show another configuration
 mechanism. That approach will often be used in container deployments,
 and is demonstrated in the runSample set of files.
@@ -76,7 +80,7 @@ there is something waiting to receive the publications when they are made. The
 
 ## Building a container for running samples
 There is an set of files in here that will show how to create a container that runs
-the `amqsput` program. The `runSample.sh` script drives the process. It will try to
+the `amqsput` program. The `runSample*.sh` scripts drive the process. It will try to
 connect to a queue manager running on the host machine.
 
 The process is split into two pieces - the first is used to compile the program, and
diff --git a/samples/runSample.bud.sh b/samples/runSample.bud.sh
@@ -0,0 +1,53 @@
+# This is an example of running one of the sample programs in a container.
+# It used buildah/podman as an alternative to 'docker'.
+
+function latestSemVer {
+  (for x in $*
+  do
+    echo $x | sed "s/^v//g"
+  done) | sort -n | tail -1
+}
+
+# Assume repo tags have been created in a sensible order. Find the mq-golang
+# version in the root go.mod file and the current Git tag for this repo.
+# Then pick the latest version to create the Docker tag
+VERDEP=`cat ../go.mod | awk '/mq-golang/ {print $2}' `
+VERREPO=`git tag -l 2>/dev/null| sort | tail -1 `
+
+VER=`latestSemVer $VERDEP $VERREPO`
+if [ -z "$VER" ]
+then
+  VER="latest"
+fi
+
+# Basic name for the container
+TAG=mq-golang-sample-amqsput
+echo Building container with tag $TAG:$VER
+
+# Build the container which includes compilation of the program.
+# The UBI variant is built on the Red Hat Universal Base Image set of containers.
+dfile="runSample.ubi.Dockerfile"
+buildah bud -t $TAG:$VER -f $dfile .
+
+if [ $? -eq 0 ]
+then
+  # This line grabs a currently active IPv4 address for this machine. It's probably
+  # not what you want to use for a real system but it's useful for testing. "localhost"
+  # does not necessarily work inside the container so we need a real address.
+  addr=`ip -4 addr | grep "state UP" -A2 | grep inet | tail -n1 | awk '{print $2}' | cut -f1 -d'/'`
+  echo "Local address is $addr"
+  port="1414"
+
+  if [ ! -z "addr" ]
+  then
+    # Run the container.
+    # We override default command line values in amqsput via env vars.
+    podman run -e MQSERVER="SYSTEM.DEF.SVRCONN/TCP/$addr($port)" \
+       -e QUEUE=DEV.QUEUE.1 \
+       -e QMGR=QM1 \
+       $TAG:$VER
+  else
+    echo "Cannot find a working address for this system"
+    exit 1
+  fi
+fi
diff --git a/samples/runSample.deb.Dockerfile b/samples/runSample.deb.Dockerfile
diff --git a/samples/runSample.sh b/samples/runSample.sh
@@ -10,7 +10,7 @@ function latestSemVer {
 # Assume repo tags have been created in a sensible order. Find the mq-golang
 # version in the root go.mod file and the current Git tag for this repo.
 # Then pick the latest version to create the Docker tag
-VERDEP=`cat ../../go.mod | awk '/mq-golang/ {print $2}' `
+VERDEP=`cat ../go.mod | awk '/mq-golang/ {print $2}' `
 VERREPO=`git tag -l 2>/dev/null| sort | tail -1 `
 
 VER=`latestSemVer $VERDEP $VERREPO`
@@ -23,8 +23,17 @@ fi
 TAG=mq-golang-sample-amqsput
 echo Building container with tag $TAG:$VER
 
-# Build the container which includes compilation of the program
-docker build -t $TAG:$VER -f runSample.Dockerfile .
+# Build the container which includes compilation of the program. Can set the FROM
+# environment variable outside this script to choose which base image to work from.
+# The UBI variant is built on the Red Hat Universal Base Image set of containers; the
+# default is built on Ubuntu/Debian containers.
+if [ "$FROM" = "UBI" ]
+then
+  dfile="runSample.ubi.Dockerfile"
+else
+  dfile="runSample.deb.Dockerfile"
+fi
+docker build -t $TAG:$VER -f  $dfile .
 
 if [ $? -eq 0 ]
 then
diff --git a/samples/runSample.ubi.Dockerfile b/samples/runSample.ubi.Dockerfile
@@ -0,0 +1,107 @@
+# © Copyright IBM Corporation 2019, 2021
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# This Dockerfile has two separate stages.
+#
+# The first stage is used to compile the Go program, where we need tools like the Go and C compilers.
+# The second stage is a runtime-only container that holds just the things we need to
+# execute the compiled program.
+#
+# Files and directories are copied from the builder container to the runtime container as needed.
+#
+# The base images are taken from the Red Hat Universal Base Images repository
+
+# Start by setting some global variables that can still be overridden on the build command line.
+ARG BASE_IMAGE=registry.access.redhat.com/ubi8/ubi
+ARG GOPATH_ARG="/go"
+
+###########################################################
+# This starts the BUILD phase
+###########################################################
+FROM $BASE_IMAGE AS builder
+
+ARG GOPATH_ARG
+ENV GOPATH=$GOPATH_ARG \
+    ORG="github.com/ibm-messaging"
+
+# Install the Go compiler and some other tools. The version of Go that
+# is available from the repository is new enough that we don't need to
+# explicitly pull it from Google. Installing Go also gives prereqs like the C compiler.
+RUN yum --disableplugin=subscription-manager -y install wget curl tar golang \
+  && yum --disableplugin=subscription-manager clean all
+
+# Create a location for the go programs and the MQ installation
+RUN mkdir -p $GOPATH/src $GOPATH/bin $GOPATH/pkg \
+  && chmod -R 777 $GOPATH \
+  && cd /tmp       \
+  && mkdir -p /opt/mqm \
+  && chmod a+rx /opt/mqm
+
+# Location of the downloadable MQ client package \
+ENV RDURL="https://public.dhe.ibm.com/ibmdl/export/pub/software/websphere/messaging/mqdev/redist" \
+    RDTAR="IBM-MQC-Redist-LinuxX64.tar.gz" \
+    VRMF=9.2.3.0
+
+# Install the MQ client from the Redistributable package. This also contains the
+# header files we need to compile against. Setup the subset of the package
+# we are going to keep - the genmqpkg.sh script removes unneeded parts
+ENV genmqpkg_incnls=1 \
+    genmqpkg_incsdk=1 \
+    genmqpkg_inctls=1
+
+RUN cd /opt/mqm \
+  && curl -LO "$RDURL/$VRMF-$RDTAR" \
+  && tar -zxf ./*.tar.gz \
+  && rm -f ./*.tar.gz \
+  && bin/genmqpkg.sh -b /opt/mqm
+
+ENV PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+
+# Copy the source file over. We also need a go.mod file
+# The source for that has a different name in the repo so it doesn't accidentally get
+# used. We rename it during this copy.
+COPY amqsput.go      $GOPATH_ARG/src
+COPY runSample.gomod $GOPATH_ARG/src/go.mod
+
+# Do the actual compile. This will automatically download the ibmmq package
+RUN cd $GOPATH_ARG/src && go build -o $GOPATH_ARG/bin/amqsput amqsput.go
+
+###########################################################
+# This starts the RUNTIME phase
+###########################################################
+# Now that there is a container with the compiled program we can build a smaller
+# runtime image. Start from one of the smaller base container images.
+FROM registry.access.redhat.com/ubi8/ubi-minimal
+ARG GOPATH_ARG
+
+# Copy over the MQ runtime client code. This does preserve the .h files used during compile
+# but those are tiny so there's no real space-saving from deleting them here.
+COPY --from=builder /opt/mqm /opt/mqm
+
+# Create some directories that may be needed at runtime, depending on the container's
+# security environment.
+RUN mkdir -p /IBM/MQ/data/errors \
+  && mkdir -p /.mqm \
+  && chmod -R 777 /IBM \
+  && chmod -R 777 /.mqm \
+  && mkdir -p /go/bin
+
+# The actual program has all of the Go runtime embedded; we only need the single
+# binary along with the MQ client libraries, for it to run.
+COPY --from=builder $GOPATH_ARG/bin/amqsput /go/bin/amqsput
+
+# The startup script will set MQSERVER and optionally set more
+# environment variables that will be passed to amqsput through this entrypoint.
+ENTRYPOINT [ "/go/bin/amqsput" ]
