In OpenShift, you can build a Docker image inside your cluster, and push it to OpenShift’s own internal image registry. Learning how to build an image from a Dockerfile is a very common stage in the journey of how to deploy your own apps on OpenShift.
Dockerfile based builds are also useful when you want to deploy an application into OpenShift, but you can’t pull it from another registry.
Build it yourself
So, you want to build an image yourself in the cluster, perhaps either using Source-to-Image, or with a Dockerfile.
Dockerfiles are pretty common, so in this article we’re going to look at some common variations on building an image in OpenShift using a Docker build, with build instructions located nicely in a Dockerfile. Nice.
TODO about Docker builds
It starts with a BuildConfig
If you haven’t taken OpenShift 101, then a BuildConfig
4 BuildConfig examples
Now you’ve learned the basics of builds, let’s take a look at some examples.
To apply each of these examples to an OpenShift cluster, you can use the
oc apply command.
1. Basic OpenShift Docker BuildConfig example (from Git)
Keeping your Dockerfile in a Git repository is a great option.
It’s easier to manage everything when you keep your build scripts in the same repository as your code.
Plus, you also get the advantage of being able to version-control your Dockerfile, just like your application’s code.
To use a Dockerfile from a Git repository, you need to specify
Docker, and then use the
dockerStrategy.dockerfilePath field to give the path to your Dockerfile.
Here’s an example:
dockerfilePath: Dockerfile # Look for Dockerfile in: gitUri/contextDir/dockerfilePath
2. Use an image stream as a base image
I like image streams, they’re a nice feature of OpenShift. They allow you to create a local “pointer” to a set of image tags.
When you use an image stream, you don’t need to hardcode the full registry URL everywhere, including your BuildConfig.
OpenShift will resolve the image and use it as the from image in your Docker build.
When you use an image stream in a BuildConfig, you can also set an image change event as a trigger – for example, to trigger a new build when a new image is pushed to a tag.
First, let’s set up an image stream to use as an example.
I create a local imagestream called
httpd, which points to Bitnami’s Apache image on Docker Hub. Here’s an example ImageStream YAML definition for that:
- name: latest
Next, create the BuildConfig, to perform a Docker build in OpenShift.
The image stream details go in the
.spec.strategy.dockerStrategy.from section, like this example:
kind: ImageStreamTag # Use an imagestream tag as 'FROM'
namespace: toms-project # Which project?
name: httpd:latest # Use the imagestream created above
- type: ImageChange # Trigger a build on image change
Now, when the build runs, OpenShift will replace the
FROM line in your Dockerfile with the image from the image stream.
In the logs, you can see OpenShift replacing the FROM instruction:
3. Dockerfile inside the BuildConfig itself
The final option I want to show you is writing a Dockerfile inside the BuildConfig itself. This is called an inline Dockerfile.
You can include a complete Dockerfile inside the BuildConfig object.
When this approach is combined with
spec.source.type=Git, OpenShift will check out code from your Git repository,
cd into the directory, then run a Docker build using your inline Dockerfile.
You can use a
| pipe symbol in YAML to mark the start of a multiline string with line breaks, so you can write a complete Dockerfile.
Here’s the example:
uri: https://github.com/monodot/container-up # clone this code
contextDir: httpd-hello-world # cd to this directory
COPY ./public_html/ /app
The syntax looks a little weird, but this trick allows you to create a custom Docker build, without needing to store the Dockerfile in a Git repository.
Thanks for reading! I hope you found these example BuildConfigs useful.
Docker builds are an alternative to source-to-image (S2I) builds and you’ll probably find them useful when you’ve already written an app with a Dockerfile, and you simply want to move your app into OpenShift.
Once you’ve got the basics of Docker builds, you might want to add some 🌟 automation 🌟 and learn how to run a Docker build inside a Jenkins pipeline on OpenShift.
And then, once you’ve built your image, how about learning how to deploy it to Kubernetes, by looking at some Kubernetes Deployment examples?