Practical Guide to OpenShift 4: Streamlining Application Deployment for Beginners
OpenShift 4, a leading enterprise-grade Kubernetes distribution by Red Hat, offers a robust and streamlined
platform for deploying and managing containerized applications. Built on top of Kubernetes, OpenShift
enhances the container orchestration capabilities with features tailored for developers and operations teams.
This guide provides a practical introduction to deploying applications on OpenShift 4, empowering beginners
to leverage its powerful features.
When do I need OpenShift?
OpenShift caters to a wide range of users, including developers, system administrators, and DevOps engineers.
It becomes particularly valuable in the following scenarios:
• Containerized Application Deployment: OpenShift simplifies the deployment and management of
containerized applications, automating tasks such as scaling, rolling updates, and health checks.
• Microservices Architecture: Its inherent support for containerization and orchestration makes
OpenShift an ideal platform for deploying and managing microservices-based applications.
• DevOps Practices: OpenShift promotes DevOps workflows through features like automated builds,
continuous integration/continuous delivery (CI/CD) pipelines, and integrated image registries.
• Enterprise-Grade Security: With built-in security features, including role-based access control
(RBAC), image signing, and security context constraints, OpenShift ensures a secure environment for
running applications.
• Hybrid Cloud Deployments: OpenShift’s ability to seamlessly manage deployments across on-
premises and cloud environments facilitates hybrid cloud strategies.
How to use OpenShift 4?
Let’s explore the fundamental steps involved in deploying an application on OpenShift 4. We’ll assume you
have access to an OpenShift cluster. If not, you can explore options like CodeReady Containers for local
development or a cloud-based OpenShift instance.
1. Accessing the OpenShift Cluster:
Connect to your OpenShift cluster using the oc command-line tool. You’ll need to provide authentication
details:
oc login -u <username> -p <password> <api_server_url>
2. Creating a Project (Namespace):
Organize your applications within projects, similar to namespaces in Kubernetes. Create a new project:
oc new-project my-application
3. Deploying from Source Code (S2I):
OpenShift’s Source-to-Image (S2I) feature simplifies application deployment from source code. It automatically
builds a container image and deploys it.
oc new-app nodejs~https://github.com/your-repo/your-app.git --name my-nodejs-app
This command:
• Downloads the source code from the specified Git repository.
• Uses the nodejs builder image to create a container image.
• Deploys the application with the name my-nodejs-app.
4. Deploying from a Container Image:
If you already have a container image, deploy it directly:
oc new-app <image_registry>/<image_name>:<image_tag> --name my-container-app
5. Exposing the Application:
1
Make your application accessible from outside the cluster using a Service and a Route:
oc expose svc/my-nodejs-app --port=8080 --target-port=8080
oc expose svc/my-nodejs-app --name my-nodejs-app-route
This creates a Route that assigns a public URL to your application.
6. Managing the Application:
Use the oc command to manage your application:
• View application logs: oc logs <pod_name>
• Scale the application: oc scale deployment/<deployment_name> --replicas=3
• Roll out updates: Modify the deployment configuration, and OpenShift will automatically handle the
update process.
Use Case: Deploying a Simple Node.js Application
Let’s deploy a simple Node.js application from a GitHub repository.
1. Create a project: oc new-project my-node-project
2. Deploy using S2I:
oc new-app nodejs~https://github.com/openshift-katacoda/nodejs-ex.git --name my-node-app
3. Expose the application:
oc expose svc/my-node-app --port=8080 --target-port=8080
oc expose svc/my-node-app --name my-node-app-route
4. Access the application: Obtain the route URL using oc get route and access your application in a
browser.
Use Case: Deploying a Pre-built Container Image:
1. Create a project: oc new-project my-image-project
2. Deploy the image (replace with your image details):
oc new-app quay.io/rhdevelopers/knote:latest --name my-knote-app
3. Expose the application (adjust ports as needed):
oc expose svc/my-knote-app --port=8080 --target-port=8080
oc expose svc/my-knote-app --name my-knote-app-route
4. Access the application: Get the route URL using oc get route.
Conclusion
OpenShift 4 provides a powerful and efficient platform for deploying and managing applications in a con-
tainerized environment. Leveraging its features, such as S2I, integrated image registries, and automated
deployment processes, simplifies the application lifecycle for developers and operations teams. By following
the practical steps outlined in this guide, beginners can confidently deploy their applications on OpenShift 4
and benefit from its robust capabilities. OpenShift streamlines container orchestration, enhancing productivity
and enabling organizations to embrace modern application development practices effectively.
