Chapter 6. Custom image builds with Buildah

Procedure

1. Starting with an empty directory, create a file named Dockerfile with the following content:

   FROM docker.io/centos:7
   RUN yum install -y buildah
   # For simplicity, /tmp/build contains the inputs we’ll be building when we
   # run this custom builder image. Normally the custom builder image would
   # fetch this content from some location at build time. (e.g. via git clone).
   ADD Dockerfile.sample /tmp/input/Dockerfile
   ADD build.sh /usr/bin
   RUN chmod a+x /usr/bin/build.sh
   # /usr/bin/build.sh contains the actual custom build logic that will be executed when
   # this custom builder image is executed.
   ENTRYPOINT ["/usr/bin/build.sh"]

2. In the same directory, create a file named Dockerfile.sample. This file will be included in the custom build image and defines the image that will be produced by the custom build:

   FROM docker.io/centos:7
   RUN touch /tmp/built

3. In the same directory, create a file named build.sh. This file contains the logic that will be executed when the custom build runs:

   #!/bin/sh
   # Note that in this case the build inputs are part of the custom builder image, but normally this
   # would be retrieved from an external source.
   cd /tmp/input
   # OUTPUT_REGISTRY and OUTPUT_IMAGE are env variables provided by the custom
   # build framework
   TAG="${OUTPUT_REGISTRY}/${OUTPUT_IMAGE}"
   
   
   # performs the build of the new image defined by Dockerfile.sample
   buildah --storage-driver vfs bud --isolation chroot -t ${TAG} .
   
   
   # buildah requires a slight modification to the push secret provided by the service
   # account in order to use it for pushing the image
   cp /var/run/secrets/openshift.io/push/.dockercfg /tmp
   (echo "{ \"auths\": " ; cat /var/run/secrets/openshift.io/push/.dockercfg ; echo "}") > /tmp/.dockercfg
   
   
   # push the new image to the target for the build
   buildah --storage-driver vfs push --tls-verify=false --authfile /tmp/.dockercfg ${TAG}

Procedure

1. Define a BuildConfig that will build your custom builder image:

   $ oc new-build --binary --strategy=docker --name custom-builder-image

2. From the directory in which you created your custom build image, run the build:

   $ oc start-build custom-builder-image --from-dir . -F

   After the build completes, your new custom builder image is available in your project in an imagestreamtag that is named custom-builder-image:latest.

Procedure

1. Create a file named buildconfig.yaml. This file defines the BuildConfig that is created in your project and executed:

   kind: BuildConfig
   apiVersion: v1
   metadata:
     name: sample-custom-build
     labels:
       name: sample-custom-build
     annotations:
       template.alpha.openshift.io/wait-for-ready: 'true'
   spec:
     strategy:
       type: Custom
       customStrategy:
         forcePull: true
         from:
           kind: ImageStreamTag
           name: custom-builder-image:latest
           namespace: <yourproject> 1
     output:
       to:
         kind: ImageStreamTag
         name: sample-custom:latest

   1

   Specify your project name.

2. Create the BuildConfig:

   $ oc create -f buildconfig.yaml

3. Create a file named imagestream.yaml. This file defines the imagestream to which the build will push the image:

   kind: ImageStream
   apiVersion: v1
   metadata:
     name: sample-custom
   spec: {}

4. Create the imagestream:

   $ oc create -f imagestream.yaml

5. Run your custom build:

   $ oc start-build sample-custom-build -F

   When the build runs, it launches a pod running the custom builder image that was built earlier. The pod runs the build.sh logic that is defined as the entrypoint for the custom builder image. The build.sh logic invokes Buildah to build the Dockerfile.sample that was embedded in the custom builder image, and then uses Buildah to push the new image to the sample-custom imagestream.