send REST message to pode in Openshift

Question

I have an openshift namespace (SomeNamespace), in that namespace I have several pods.

I have a route associated with that namespace (SomeRoute).

In one of pods I have my spring application. It has REST controllers.

I want to send message to that REST controller, how can I do it?

I have a route URL: https://some.namespace.company.name. What should I find next?

I tried to send requests to https://some.namespace.company.name/rest/api/route but it didn't work. I guess, I must somehow specify pod in my URL, so route will redirect requests to concrete pod but I don't know how I can do it.

Answer 1

You don't need to specify the pod in the route.

The chain goes like this:

• Route exposes a given port of a Service
• Service selects some pod to route the traffic to by its .spec.selector field

You need to check your Service and Route definitions.

Example service and route (including only the related parts of the resources):

Service

spec:
  ports:
  - name: 8080-tcp
    port: 8080
    protocol: TCP
    targetPort: 8080
  selector:
    <label-key>: <label-value>

Where label-key and label-value is any label key-value combination that selects your pod with the http application.

Route

spec:
  port:
    targetPort: 8080-tcp <port name of the service>
  to:
    kind: Service
    name: <service name>

When your app exposes some endpoint on :8080/rest/api, you can invoke it with <route-url>/rest/api

You can try it out with some example application (some I found randomly on github, to verify everything works correctly on your cluster):

• create a new app using s2i build from github repository: oc new-app registry.redhat.io/openjdk/openjdk-11-rhel7~https://github.com/redhat-cop/spring-rest

• wait until the s2i build is done and the pod is started

• expose the service via route: oc expose svc/spring-rest

• grab the route url: oc get route spring-rest -o jsonpath='{.spec.host}'

• invoke the api: curl -k <route-url>/v1/greeting

• response should be something like: {"id":3,"content":"Hello, World!"}

Answer 2

Routes are an OpenShift-specific way of exposing a Service outside the cluster. But, if you are developing an app that will be deployed onto OpenShift and Kubernetes, then you should use Kubernetes Ingress objects.

Using Ingress means that your app’s manifests are more portable between different Kubernetes clusters.

From the official Kubernetes docs:

• An Ingress may be configured to give Services externally-reachable URLs, load balance traffic, terminate SSL / TLS, and offer name-based virtual hosting.
• Ingress exposes HTTP and HTTPS routes from outside the cluster to services within the cluster.
• Traffic routing is controlled by rules defined on the Ingress resource.

So, if you want to reach your REST controllers:

• from within the k8s cluster. Create a k8s Service to expose an application running on a set of Pods as a network service:

apiVersion: v1
kind: Service
metadata:
  name: my-service
  namespace: your-namespace
spec:
  selector:
    app: MyApp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080

This specification creates a new Service object named "my-service", which targets TCP port 8080 on any Pod with the app=MyApp label. You can reach the REST controller using this URL:

http://my-service

• externally. Create an Ingress resource to configure externally-reachable URLs (a k8s Service 'my-service' should exist):

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ingress-name
  namespace: your-namespace
spec:
  rules:
  - host: "foo.bar.com"  
    http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: my-service
            port:
              number: 80

You can reach the REST controller using this URL:

http://foo.bar.com