Introduction

OpenShift is a powerful container orchestration platform that allows you to deploy and manage containerized applications at scale. In this guide, you'll learn how to use the Go programming language to build and deploy applications on OpenShift. We'll cover setting up OpenShift, creating a Go application, and deploying it using sample code and detailed steps.


Prerequisites

Before getting started, make sure you have GoLang installed, access to an OpenShift cluster, and the OpenShift Command Line Interface (CLI) installed on your system. Familiarity with GoLang and containerization concepts will be helpful.


Setting Up OpenShift

OpenShift offers various deployment options, including local clusters, cloud-managed clusters, and self-hosted clusters. Here's an overview of the necessary steps to set up OpenShift locally using Minishift:

  1. Install Minishift: If you're setting up a local OpenShift cluster, install Minishift and configure it to use your hypervisor (e.g., VirtualBox).
  2. Start the Cluster: Use 'minishift start' to create and start the local OpenShift cluster.
  3. Log In to OpenShift: Use 'oc login' to log in to your OpenShift cluster.

Creating a Go Application

Develop your Go application as per your requirements. Ensure it's containerized and ready for deployment. Here's a simple example of a Go web server:

                            package main
                import (
                    "fmt"
                    "net/http"
                )
                func main() {
                    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
                        fmt.Fprint(w, "Hello, OpenShift!")
                    })
                    http.ListenAndServe(":8080", nil)
                }

Deploying on OpenShift

Deploying your Go application on OpenShift involves creating a Docker image, defining Kubernetes deployment configurations, and using OpenShift resources. Here are the general steps:

  1. Containerize Your Application: Create a Dockerfile to containerize your Go application.
  2. Build the Docker Image: Use 'docker build' to build the Docker image for your application.
  3. Deploy to OpenShift: Use 'oc new-app' to create an OpenShift application from your Docker image.
  4. Expose Your Service: Use 'oc expose' to expose your service to the outside world.

Sample Code

Here's an example of a simple Go web server and a sample Dockerfile for containerization. You can adapt this code to your application's requirements.

                            package main
                import (
                    "fmt"
                    "net/http"
                )
                func main() {
                    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
                        fmt.Fprint(w, "Hello, OpenShift!")
                    })
                    http.ListenAndServe(":8080", nil)
                }

Dockerfile:

                            # Use the official Golang image
                FROM golang:1.16
                # Set the working directory
                WORKDIR /app
                # Copy the local code to the container
                COPY . .
                # Build the Go application
                RUN go build -o main
                # Expose port 8080
                EXPOSE 8080
                # Command to run the executable
                CMD ["./main"]

Conclusion

Leveraging the Go programming language for building and deploying applications on OpenShift allows you to harness the power of container orchestration. This guide covered setting up OpenShift, creating a Go application, and deploying it. With this knowledge, you can effectively develop and deploy containerized Go applications on OpenShift.


Further Resources

To further explore GoLang development on OpenShift, consider the following resources: