Goglides Dev 🌱

Cover image for Quick Testing of Data Science Applications on Red Hat OpenShift AI without creating container image
Balkrishna Pandey
Balkrishna Pandey

Posted on

Quick Testing of Data Science Applications on Red Hat OpenShift AI without creating container image

Developing data science applications often requires rapid testing and iteration. If you're using Red Hat OpenShift AI (RHOAI), you can set up a temporary testing environment that allows you to bypass the complexities of containerization during the initial development phase. This guide outlines a simple workaround to test your applications directly from your local machine or using DNS.

Create a Simple Web Application

Let's start by creating a basic web application within your RHOAI environment. Use the terminal in your RHOAI workbench to create an HTML file named index.html. This file will contain a greeting message that acknowledges the RHOAI environment:

echo "<h1>Hello world from Red Hat OpenShift AI<br/></h1>" > index.html
Enter fullscreen mode Exit fullscreen mode

Now run a simple HTTP server to serve your page by executing:

python -m http.server
Enter fullscreen mode Exit fullscreen mode

You should see an output similar to this.

Python http.server

Create a Kubernetes Service

Next create a Kubernetes Service, to manage access to your application:

kind: Service
apiVersion: v1
  name: <workbench-name>-custom-app
    - protocol: TCP
      port: 80
      targetPort: 8000
  type: ClusterIP
    statefulset: <workbench-name>
Enter fullscreen mode Exit fullscreen mode

Establish an OpenShift Route

To make your service accessible outside the internal network, set up an OpenShift route:

kind: Route
apiVersion: route.openshift.io/v1
  name: <workbench-name>-custom-app
    kind: Service
    name: <workbench-name>-custom-app
    targetPort: 8000
  wildcardPolicy: None
Enter fullscreen mode Exit fullscreen mode

Configure a Network Policy

Ensure your application is reachable by defining a network policy that allows traffic on port 8000:

kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
  name: <workbench-name>-custom-app
      notebook-name: <workbench-name>
    - ports:
        - protocol: TCP
          port: 8000
    - Ingress
Enter fullscreen mode Exit fullscreen mode

Applying YAML Configuration in OpenShift

The following note provides instructions on how to apply a YAML configuration file in the OpenShift Developer Console. Ensure that the developer user has access to this operation.

  • Navigate to the Developer section in the OpenShift Console.
  • Click on the +Add button.
  • Select the Import YAML option.
  • Paste your YAML configuration into the editor.
  • Ensure to replace with the appropriate name throughout the YAML file.

The screenshot below demonstrates this process:
Apply config using developer console

Now you can access the application using the browser as shown in following screenshots,

Openshift Routes

The default pattern for an OpenShift route typically follows a structured format that includes several components to ensure that the route is unique and accessible within the hosted environment. For the example you provided, the pattern can be broken down as follows:

  • http:// - This is the protocol used for the HTTP connection.
  • *rhoai-workbench-port-8000-pythonapp *- This part usually includes the name of the application or service, which in this case is indicative of the specific workbench and port used, along with the name of the application.
  • -demoproject - This often represents the name of the project or namespace within OpenShift where the application is deployed.
  • *.apps.cloudc.xtoph.dfw.ocp.run/ *- This suffix represents the cluster's domain, which typically includes subdomains or identifiers for the specific OpenShift cluster and its geographical or organizational placement.
  • This format is designed to automatically provide a unique and direct URL to each deployed service, facilitating access without manual DNS configuration.

Development Considerations on RHOAI

When developing on RHOAI, this setup allows you to quickly test changes without the need for full deployment cycles. However, remember that this method is suitable for development and testing phases only. For production deployments:

  • Containerize Your Application: Build a container image using a Containerfile.
  • Deploy Using Kubernetes Objects: Use deployment objects to manage and scale your application effectively.

Bonus: Run a Simple Flask Server

Sometimes, the application server itself can block traffic, so ensure that this issue isn't affecting your setup. In this demonstration, I am using a simple Flask-based application to illustrate the process.

  • Ensure you have Python and Flask installed. If not, you can install Flask using pip:
pip install flask
Enter fullscreen mode Exit fullscreen mode
  • Create a new Python file, e.g., app.py, and add the following code:
from flask import Flask
import socket

app = Flask(__name__)

def hello_world():
    ip = socket.gethostbyname(socket.gethostname())
    return f"Hello world from Red Hat OpenShift AI, I am running inside {ip}"

if __name__ == '__main__':
    app.run(host='', port=8000)
Enter fullscreen mode Exit fullscreen mode

Here this app.run(host='', port=8000) starts the Flask development server, making it accessible on all network interfaces (external access) at port 8000. This is useful for testing and development purposes, especially when you want to access the application from other devices or environments.

  • Run your Flask application using the following command:
python app.py
Enter fullscreen mode Exit fullscreen mode

Your Flask server will start and be accessible at http://<your-openshift-route>:8000. The application will dynamically fetch and display the server's IP address.

Top comments (0)