Flexible Ingress Configuration Example

Oct 13, 2025 by magicalceylontours.com 4 views

Problem: Can't Expose Frontend and Backend on Different Paths

When it comes to deploying applications with multiple components, such as frontend and backend services, it's essential to have a flexible and scalable ingress configuration. However, the current chart for Ingress does not support exposing frontend and backend services on different paths, which can lead to limitations and inflexibility in application deployment.

The Current Ingress Chart

The current Ingress chart is too prescriptive about what is allowed, with a host rule containing only one port/path and an extraHosts rule forcing you to add another host that supports only one port/path. This can be seen in the following code snippet:

  rules:
    - host: {{ include "common.tplvalues.render" ( dict "value" .Values.ingress.host "context" $ ) }}
      http:
        paths:
          - path: {{ .Values.ingress.path }}
            pathType: Prefix
            backend:
              service:
                name: {{ include "common.names.fullname" . }}
                port:
                  number: {{ .Values.service.ports.backend }}
    {{- range .Values.ingress.extraHosts }}
    - host: {{ .name | quote }}
      http:
        paths:
          - path: {{ default $.Values.ingress.path .path }}
            pathType: {{ default "Prefix" .pathType }}
            backend:
              service:
                name: {{ include "common.names.fullname" $ }}
                port:
                  number: {{ default $.Values.service.ports.backend .port }}

Use Case: Deploying Backstage with Github OAuth Authentication

One use case where this limitation becomes apparent is when deploying Backstage with Github OAuth authentication. In this scenario, a callback address is required that hits the backend service. However, having two different hosts for the frontend and backend services is not desirable. Instead, a single host with path-based routing is preferred, where the frontend and backend services can be exposed on different paths, such as:

https://backstage.internal.company.com/frontend
https://backstage.internal.company.com/backend

Suggestion: Flexible Ingress Configuration

To address this limitation, the Ingress chart should have a more flexible approach to ingress configuration, allowing multiple path/port rules within a single host item. Instead of reinventing the wheel piecemeal, the example from the NGINX chart can be used as a reference, which has support for flexible host/port/path combinations.

Flexible Ingress Configuration Example

The NGINX chart provides an example of a flexible ingress configuration that can be used as a reference. The following code snippet shows how multiple path/port rules can be defined within a single host item:

  rules:
    - host: {{ include "common.tplvalues.render" ( dict "value" .Values.ingress.host "context" $ ) }}
      http:
        paths:
          - path: /frontend
            pathType: Prefix
            backend:
              service:
                name: {{ include "common.names.fullname" . }}
                port:
                  number: {{ .Values.service.ports.backend }}
          - path: /backend
            pathType: Prefix
            backend:
              service:
                name: {{ include "common.names.fullname" . }}
                port:
                  number: {{ .Values.service.ports.backend }}
    {{- range .Values.ingress.extraHosts }}
    - host: {{ .name | quote }}
      http:
        paths:
          - path: {{ default "/frontend" .path }}
            pathType: {{ default "Prefix" .pathType }}
            backend:
              service:
                name: {{ include "common.names.fullname" $ }}
                port:
                  number: {{ default $.Values.service.ports.backend .port }}
          - path: {{ default "/backend" .path }}
            pathType: {{ default "Prefix" .pathType }}
            backend:
              service:
                name: {{ include "common.names.fullname" $ }}
                port:
                  number: {{ default $.Values.service.ports.backend .port }}

Conclusion

Q: What is the current limitation of the Ingress chart?

A: The current Ingress chart is too prescriptive about what is allowed, with a host rule containing only one port/path and an extraHosts rule forcing you to add another host that supports only one port/path.

Q: What is the use case where this limitation becomes apparent?

A: One use case where this limitation becomes apparent is when deploying Backstage with Github OAuth authentication. In this scenario, a callback address is required that hits the backend service. However, having two different hosts for the frontend and backend services is not desirable.

Q: What is the suggested solution to address this limitation?

A: The suggested solution is to have a more flexible approach to ingress configuration, allowing multiple path/port rules within a single host item. Instead of reinventing the wheel piecemeal, the example from the NGINX chart can be used as a reference, which has support for flexible host/port/path combinations.

Q: What is the benefit of using a flexible ingress configuration?

A: Using a flexible ingress configuration allows developers to deploy applications with multiple components, such as frontend and backend services, in a scalable and flexible manner. This enables developers to expose frontend and backend services on different paths, such as:

https://backstage.internal.company.com/frontend
https://backstage.internal.company.com/backend

Q: How can a flexible ingress configuration be achieved?

A: A flexible ingress configuration can be achieved by defining multiple path/port rules within a single host item. This can be done by using the example from the NGINX chart as a reference, which has support for flexible host/port/path combinations.

Q: What is the example of a flexible ingress configuration?

A: The example of a flexible ingress configuration is shown in the following code snippet:

  rules:
    - host: {{ include "common.tplvalues.render" ( dict "value" .Values.ingress.host "context" $ ) }}
      http:
        paths:
          - path: /frontend
            pathType: Prefix
            backend:
              service:
                name: {{ include "common.names.fullname" . }}
                port:
                  number: {{ .Values.service.ports.backend }}
          - path: /backend
            pathType: Prefix
            backend:
              service:
                name: {{ include "common.names.fullname" . }}
                port:
                  number: {{ .Values.service.ports.backend }}
    {{- range .Values.ingress.extraHosts }}
    - host: {{ .name | quote }}
      http:
        paths:
          - path: {{ default "/frontend" .path }}
            pathType: {{ default "Prefix" .pathType }}
            backend:
              service:
                name: {{ include "common.names.fullname" $ }}
                port:
                  number: {{ default $.Values.service.ports.backend .port }}
          - path: {{ default "/backend" .path }}
            pathType: {{ default "Prefix" .pathType }}
            backend:
              service:
                name: {{ include "common.names.fullname" $ }}
                port:
                  number: {{ default $.Values.service.ports.backend .port }}

Q: What is the conclusion of this article?

A: In conclusion, the current Ingress chart does not support exposing frontend and backend services on different paths, which can lead to limitations and inflexibility in application deployment. A more flexible approach to ingress configuration is required, allowing multiple path/port rules within a single host item. The example from the NGINX chart can be used as a reference for a flexible ingress configuration. By adopting this approach, developers can deploy applications with multiple components, such as frontend and backend services, in a scalable and flexible manner.