From Code to Deployment: Building and Launching Apps on OpenShift with Docker


Building and launching applications has become a complex process in today’s digital world. The rise of containerization has made it easier to package an application and its dependencies into a single container that can run on any platform.

This is where OpenShift comes in, offering an enterprise-grade Kubernetes container platform for deploying, scaling, and managing containerized applications. Docker complements OpenShift by providing a standardized way to create, distribute, and run containers across different environments.

What Is OpenShift?

OpenShift is a cloud-based Container Application Platform that allows users to develop, deploy, and manage applications on the cloud. It is built on top of Kubernetes, which makes it easy for users to deploy their containerized applications with reduced complexity. OpenShift was developed by Red Hat as an open-source platform that offers a secure multi-tenant environment with integrated CI/CD pipelines.

The Role of Docker in App Development

Docker has revolutionized app development by providing a way to automate the deployment of applications inside portable containers. These containers are lightweight and come with everything needed to run the application including code, libraries, dependencies, runtime environment settings and even system tools such as databases or web servers. Using Docker simplifies the process of deploying apps across different environments since each app runs consistently regardless of the underlying operating system or infrastructure.

Why Building Apps with OpenShift And Docker Matters

Today’s business demands require apps to be built quickly while also being scalable and responsive under heavy traffic loads. This requires highly automated processes for building and deploying apps while also ensuring they remain secure throughout their lifecycle.

This is where using OpenShift along with Docker can make a significant impact since it provides developers with an efficient way to build modern cloud-native applications that can be deployed seamlessly across different environments. The combination of these two technologies can help ensure that apps are deployed faster, run consistently across different environments, and are always up to date with the latest security patches and updates.

Understanding the Basics

An Overview of Containerization and its Benefits

Containerization is an approach that allows developers to build, package, and deploy applications in a portable and efficient way. It encapsulates an application along with its dependencies and libraries, providing a consistent runtime environment across multiple platforms. Containerization allows applications to run seamlessly across different operating systems while ensuring that they operate optimally.

Containerization offers several benefits over traditional methods of software development. Firstly, it provides a more efficient utilization of hardware resources because the application runs directly on the host system’s kernel without requiring a separate virtual machine (VM) for each application or environment.

Secondly, it simplifies deployment and maintenance by standardizing the runtime environment across all stages of software development. Containerization enables faster delivery of new features by eliminating compatibility issues between different environments.

Introduction to Dockerfile and How It Works

A Dockerfile is a text file that specifies the configuration required to build a Docker image. The Docker image contains all the necessary files, libraries, and dependencies needed to run an application within a containerized environment. A Dockerfile consists of various instructions that define how images should be built.

The basic format for creating a Dockerfile involves specifying an OS base image followed by installing dependencies such as web servers or programming languages. Each instruction in the file creates a new layer in the final image; this means that changes made in one layer do not affect subsequent layers unless specifically instructed.

Dockerfiles can also include configuration settings such as port numbers or environmental variables used by applications within containers. This allows developers to create highly configurable images for their applications.

Setting Up OpenShift Environment for App Deployment

OpenShift is a Kubernetes-based platform designed specifically for deploying containerized applications at scale within enterprise environments. To set up an OpenShift environment for app deployment requires creating a cluster, adding nodes to the cluster, and then configuring the platform to manage containerized applications.

OpenShift provides developers with an easy-to-use web console for managing applications, which can be accessed from any device or location. It also provides various tools for monitoring and scaling applications within the environment.

OpenShift’s security features ensure that applications are protected against potential threats such as vulnerabilities or malicious attacks. Understanding containerization and its benefits is critical to building and launching apps on OpenShift with Docker.

Developers should familiarize themselves with Dockerfile syntax and OpenShift configuration settings to create highly configurable images that can be easily scaled in production environments. With an optimized setup of OpenShift environment, developers can build scalable apps that will run consistently in a containerized environment while enjoying ease of deployment and maintenance provided by OpenShift.

Building Apps with Docker on OpenShift

Creating a Dockerfile for the app

The first step in building an app on OpenShift with Docker is to create a Dockerfile. A Dockerfile is a configuration file that contains instructions for building the image.

It specifies the base image, adds any necessary packages or libraries, and sets up any environment variables required by the app. The instructions in a Dockerfile are executed in order, so it’s important to structure the file correctly.

To create a Dockerfile, start by identifying the base image that you want to use. This is typically an existing image from a public registry like Docker Hub or Red Hat’s Container Catalog.

Once you’ve identified your base image, add any additional packages or libraries required by your app using package managers like apt-get, yum or apk. Set up any environment variables required by your app.

Building the image using Docker build command

Once you have created your Dockerfile for your application on OpenShift, you can use the docker build command to create an image of your application. In this process, docker reads instructions from the specified docker file and builds an initial container image based on those instructions.

When running this command you can specify options such as -t [image-name], which tags an existing repository into an empty directory; -f [docker-file], which specifies that we will be using another file other than “DockerFile” and if we have more than one method of building our container as well as specifying where to find dependencies and how they are made available within our container. During this process if there are errors encountered during initialization then we will see them printed out along with their associated exit codes before proceeding onto another step of creating our application images.

Pushing the image to OpenShift registry

After creating an image using the docker build command, we need to push it to our OpenShift registry so that we can deploy it. OpenShift has a built-in container registry that allows us to store and manage our images.

To push an image to the OpenShift registry, start by logging in using the oc login command with your credentials. Once you are logged in, you can use the oc new-app command to create a new app using your image.

This will create a new deployment configuration and pod for your application. If you have an existing deployment configuration, you can update it with the oc set command.

After deploying your app, you can monitor its status using the oc get pods or oc logs commands. If there are any errors or issues with your app, these commands will help you diagnose and troubleshoot them.

By following these steps, we can build and deploy apps on OpenShift with Docker quickly and efficiently. The use of containers allows for greater portability and scalability of applications while also simplifying management of dependencies and configurations.

Deploying Apps on OpenShift

Now that we have built our application and created a Docker image, it’s time to deploy the application on OpenShift. OpenShift is a Kubernetes-based container application platform, which provides an environment for deploying applications in containers. To deploy an application on OpenShift, we first need to create a project and then deploy the application using Kubernetes deployment configuration.

Creating a new project in OpenShift

To create a new project in OpenShift, log into the web console and click on the “Create Project” button. This will bring up a dialog box where you can specify the name of your new project and select its display name, description, and other settings. Once you have entered all the required information, click on “Create” to create your new project. After creating our new project, we can proceed with deploying our app using Kubernetes deployment configuration.

Deploying the app using Kubernetes deployment configuration

To deploy an app on OpenShift using Kubernetes deployment configuration, we need to define our deployment configuration through a YAML file. The YAML file includes information about how many instances of our app should run (replicas), which Docker image to use, what ports to expose for networking, etc. The following is an example YAML file that deploys our sample Python Flask web application:

apiVersion: apps/v1 

kind: Deployment metadata:

name: my-app spec:

replicas: 2 selector:

matchLabels: app: my-app

template: metadata:

labels: app: my-app

spec: containers:

- name: my-app-container image:

ports: - containerPort: 5000

Once we have created our YAML file, we can deploy the app by running the following command:

$ oc apply -f my-app-deployment.yaml

Scaling up or down the app depending on traffic

One of the key benefits of deploying an application in OpenShift is that it allows us to scale our application easily based on traffic. We can scale up or down our application by increasing or decreasing the number of replicas specified in our deployment configuration YAML file. To scale up our web application, we can increase the number of replicas in our deployment configuration YAML file and then apply the changes using the following command:

$ oc apply -f my-app-deployment.yaml 

To scale down our web application, we can reduce the number of replicas in our deployment configuration YAML file and then apply the changes using a similar command.

Deploying applications on OpenShift with Docker provides a powerful platform for building and launching highly scalable and resilient applications. In this section, we learned how to create a new project, deploy web applications using Kubernetes deployment configuration files as well as scaling up or down based on traffic. With these skills, you are now ready to dive deeper into building more complex applications on OpenShift with Docker.

Monitoring and Managing Apps on OpenShift

The Importance of Monitoring

Monitoring is an essential aspect of application development and deployment. It helps to identify problems before they cause significant issues or downtime.

With OpenShift, you can monitor the health of your applications using various tools like Prometheus, Grafana, and others. These tools allow you to collect metrics from various sources and create visualizations that help you understand how your application is performing.

Setting up Monitoring Tools like Prometheus and Grafana

Prometheus is a popular monitoring tool used for collecting metrics from containerized applications. It offers a powerful query language that allows developers to filter and aggregate data in real-time.

Grafana, on the other hand, is a visualization tool that allows developers to create beautiful dashboards with custom charts and graphs. To set up Prometheus on OpenShift, you need to create a new project in OpenShift and then deploy the Prometheus operator using YAML manifests or the web console.

Once deployed, you can configure Prometheus rules to collect metrics from your application pods using ServiceMonitor objects. Setting up Grafana requires similar steps: create a new project in OpenShift, deploy the Grafana operator using YAML manifests or the web console, configure data sources like Prometheus for collecting metrics, define dashboards with custom charts/graphs.

Managing Logs using EFK Stack

Logs are critical for debugging issues in production environments. The EFK stack (Elasticsearch, Fluentd, Kibana) provides a centralized logging solution for containerized applications.

Elasticsearch stores logs as documents that are easily searchable by keywords or phrases. Fluentd collects logs from multiple sources (containers/pods) and sends them to Elasticsearch for storage/querying purposes.

Kibana offers visualization capabilities like dashboards/visualizations based on log data stored in Elasticsearch. To set up EFK stack on OpenShift, you need to create a new project in OpenShift and deploy the EFK stack operator using YAML manifests or the web console.

Once deployed, you can configure Fluentd to collect logs from your application pods using ConfigMaps. Elasticsearch and Kibana are automatically configured by the operator.

Performing Rolling Updates or Rollbacks

Rolling updates and rollbacks are essential features for deploying applications without downtime. A rolling update involves updating pods one at a time, ensuring that there is always a minimum number of available replicas during the process.

If something goes wrong during an update, it’s easy to roll back to the previous version. To perform rolling updates or rollbacks on OpenShift, you need to create a deployment configuration object that defines how many replicas of your application should be running at any given time.

Then, when it’s time to update or rollback, simply edit the deployment configuration object with your new image version/tag and trigger a rollout. Monitoring and managing applications on OpenShift is critical for ensuring their availability and reliability in production environments.

Tools like Prometheus, Grafana, EFK Stack make it easier than ever before to collect metrics, visualize data trends over time and troubleshoot issues quickly. With rolling updates and rollbacks enabled by default on OpenShift deployments configurations managing changes becomes easier than ever before!


In this article, we explored the process of building and launching apps on OpenShift with Docker. We discussed the importance of containerization and how Docker makes it easy to build and deploy applications in an efficient and reliable way.

We looked at how to create a Dockerfile for our app, build the image using Docker build command, push the image to OpenShift registry, and finally deploy the app using Kubernetes deployment configuration. Additionally, we examined some best practices for monitoring logs, scaling up/down an application depending on traffic needs, performing rolling updates or rollbacks.

Summary of Key Points

The key takeaway from this article is that OpenShift with Docker is a powerful tool that can help developers streamline their app development process by providing a consistent environment for building and deploying applications in containers. Thanks to containerization technology like Docker, developers can easily create portable images of their application code along with all necessary dependencies.

By leveraging OpenShift’s Kubernetes-based orchestration capabilities – which provide extensive automation tools such as automatic scaling, load balancing, service discovery etc., – developers can easily manage their applications’ lifecycle from code to deployment. Moreover, by implementing monitoring solutions like Prometheus/Grafana or logging solutions such as EFK stack (Elasticsearch/Fluentd/Kibana), development teams can gain visibility into application performance metrics while keeping track of any errors that might occur.

Future Scope

From a broader perspective of software development trends: building apps with containers on cloud platforms like Openshift is becoming increasingly popular among software engineers worldwide as it promotes faster innovation cycles through continuous delivery pipelines across various environments (development/staging/production). This trend will continue to grow thanks to its practicality; however it also presents challenges in terms of security considerations such as network isolation between containers or proper filesystem permissions management within containers hosts etc

Final Thoughts

OpenShift with Docker is a game-changer for developers, allowing them to build and deploy applications in a reliable, efficient manner that promotes continuous delivery pipelines. Through containerization technology and automated orchestration capabilities like Kubernetes, developers can easily manage their application lifecycle from code to deployment while also monitoring performance metrics and keeping track of errors in real time. Looking ahead, the future scope of building apps with containers on cloud platforms like OpenShift is bright as it enables faster innovation cycles through continuous delivery pipelines across different environments.

Though we should remain vigilant about security considerations – such as network isolation between containers or proper filesystem permissions management – the benefits these technologies provide far outweigh any challenges they pose. With OpenShift and Docker, developers have access to powerful tools that will continue to shape the software development landscape for years to come.

Related Articles