How to serve static contents in a kubernetes application

Question

I have a small java webapp comprising of three microservices - api-service,book-service and db-service all of which are deployed on a kubernetes cluster locally using minikube.

I am planning to keep separate UIs for api-service and book-service , with the common static files served from a separate pod, probably an nginx:alpine image.

I was able to create a front end that serves the static files from nginx:alpine referring to this tutorial.

I would like to use ingress-nginx controller for routing requests to the two services.

The below diagram crudely shows where I am now.

I am confused as to where I should place the pod that serves the static content, and how to connect it to the ingress resource.I guess that keeping a front end pod before ingress defeats the purpose of ingress-nginx controller. What is the best practice to serve static files. Appreciate any help. Thanks.

Solution 1

Looks like you are confusing the fact that users, browsing online, will trigger standard requests to both "download" your static content, and use your 2 APIs (book and api). It's not the NGINX service serving the static content that is accessing your APIs, but the users browsers/applications, and they do that exactly the same for both static content and APIs (former has more/specific headers and data, like auth...).

On your diagram you'll want to put your new static-service at the exact same level as your book-service and api-service, ie behind the ingress. But your static-service won't have a link with the db-service like the other 2. Then just complete your ingress rules, with the static-service at the end as in this example:

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: your-global-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: foo.bar.com
    http:
      paths:
      - path: /book-service
        backend:
          serviceName: book-service
          servicePort: 80
      - path: /api-service
        backend:
          serviceName: api-service
          servicePort: 80
      - path: /
        backend:
          serviceName: static-service
          servicePort: 80

You'll have to adjust your services names and ports, and pick the paths you want your users to access your APIs, in the example above you'd have:

• foo.bar.com/book-service for your book-service
• foo.bar.com/api-service for the api-service
• foo.bar.com/ ie everything else going to the static-service

Solution 2

You should have, 3 distinct pods I guess : - static - book-service - api-service

The static pod will most likely not scale at the same speed than the two other.

Creating the services for each of your deployment. Then use the ingres to route the traffic on the proper endpoint.

Is it something like that you are trying to achieve?

Comments

[aswin prabhakar]

It works!! Getting the ingress rules configured took some time though. Shall I take it then ,that this is the best to way to serve static files in kubernetes microservice architecture?

[dotdotdotPaul]

If your dynamic services need access to the / path, you can also invert this, so everything coming in under, for example, /assets/ are all routed based on that prefix in the URL, and then your app can have free reign to operate like a top-level entity. I also found that I needed to add the trailing / on the paths in order for the subdirectories to get passed along (ie. in the example above, ONLY "/book-service" would be forwarded, but not "/book-service/new"). At least on GKE it seemed to work that way.