feat: support regex in path (#779)

docs/en/latest/concepts/annotations.md

@@ -131,3 +131,43 @@ spec:
             port:
               number: 80
 ```
+
+Path regular expression
+---------
+
+You can use the follow annotations to enable path regular expression
+
+* `k8s.apisix.apache.org/use-regex`
+
+If this annotations set to `true` and the `PathType` set to `ImplementationSpecific`, the path will be match as regular expression.
+
+For example, the follwing Ingress. Request path with `/api/*/action1` will use `service1` and `/api/*/action2` will be use `service2`
+
+```yaml
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  annotations:
+    kubernetes.io/ingress.class: apisix
+    k8s.apisix.apache.org/use-regex: "true"
+  name: ingress-v1
+spec:
+  rules:
+  - host: httpbin.org
+    http:
+      paths:
+      - path: /api/.*/action1
+        pathType: ImplementationSpecific
+        backend:
+          service:
+            name: service1
+            port:
+              number: 80
+      - path: /api/.*/action2
+        pathType: ImplementationSpecific
+        backend:
+          service:
+            name: service2
+            port:
+              number: 80
+```

pkg/kube/translation/annotations/cors.go

@@ -19,10 +19,10 @@ import (
 )
 
 const (
-	_enableCors       = "k8s.apisix.apache.org/enable-cors"
-	_corsAllowOrigin  = "k8s.apisix.apache.org/cors-allow-origin"
-	_corsAllowHeaders = "k8s.apisix.apache.org/cors-allow-headers"
-	_corsAllowMethods = "k8s.apisix.apache.org/cors-allow-methods"
+	_enableCors       = AnnotationsPrefix + "enable-cors"
+	_corsAllowOrigin  = AnnotationsPrefix + "cors-allow-origin"
+	_corsAllowHeaders = AnnotationsPrefix + "cors-allow-headers"
+	_corsAllowMethods = AnnotationsPrefix + "cors-allow-methods"
 )
 
 type cors struct{}

pkg/kube/translation/annotations/iprestriction.go

@@ -19,8 +19,8 @@ import (
 )
 
 const (
-	_allowlistSourceRange = "k8s.apisix.apache.org/allowlist-source-range"
-	_blocklistSourceRange = "k8s.apisix.apache.org/blocklist-source-range"
+	_allowlistSourceRange = AnnotationsPrefix + "allowlist-source-range"
+	_blocklistSourceRange = AnnotationsPrefix + "blocklist-source-range"
 )
 
 type ipRestriction struct{}

pkg/kube/translation/annotations/redirect.go

@@ -19,7 +19,7 @@ import (
 )
 
 const (
-	_httpToHttps = "k8s.apisix.apache.org/http-to-https"
+	_httpToHttps = AnnotationsPrefix + "http-to-https"
 )
 
 type redirect struct{}

pkg/kube/translation/annotations/rewrite.go

@@ -21,9 +21,9 @@ import (
 )
 
 const (
-	_rewriteTarget              = "k8s.apisix.apache.org/rewrite-target"
-	_rewriteTargetRegex         = "k8s.apisix.apache.org/rewrite-target-regex"
-	_rewriteTargetRegexTemplate = "k8s.apisix.apache.org/rewrite-target-regex-template"
+	_rewriteTarget              = AnnotationsPrefix + "rewrite-target"
+	_rewriteTargetRegex         = AnnotationsPrefix + "rewrite-target-regex"
+	_rewriteTargetRegexTemplate = AnnotationsPrefix + "rewrite-target-regex-template"
 )
 
 type rewrite struct{}

pkg/kube/translation/annotations/types.go

@@ -18,6 +18,11 @@ import (
 	"strings"
 )
 
+const (
+	// AnnotationsPrefix is the apisix annotation prefix
+	AnnotationsPrefix = "k8s.apisix.apache.org/"
+)
+
 // Extractor encapsulates some auxiliary methods to extract annotations.
 type Extractor interface {
 	// GetStringAnnotation returns the string value of the target annotation.

pkg/kube/translation/ingress.go

@@ -28,16 +28,23 @@ import (
 
 	"github.com/apache/apisix-ingress-controller/pkg/id"
 	kubev2beta3 "github.com/apache/apisix-ingress-controller/pkg/kube/apisix/apis/config/v2beta3"
+	apisixconst "github.com/apache/apisix-ingress-controller/pkg/kube/apisix/const"
+	"github.com/apache/apisix-ingress-controller/pkg/kube/translation/annotations"
 	"github.com/apache/apisix-ingress-controller/pkg/log"
 	apisixv1 "github.com/apache/apisix-ingress-controller/pkg/types/apisix/v1"
 )
 
+const (
+	_regexPriority = 100
+)
+
 func (t *translator) translateIngressV1(ing *networkingv1.Ingress) (*TranslateContext, error) {
 	ctx := &TranslateContext{
 		upstreamMap: make(map[string]struct{}),
 	}
 	plugins := t.translateAnnotations(ing.Annotations)
-
+	annoExtractor := annotations.NewExtractor(ing.Annotations)
+	useRegex := annoExtractor.GetBoolAnnotation(annotations.AnnotationsPrefix + "use-regex")
 	// add https
 	for _, tls := range ing.Spec.TLS {
 		apisixTls := kubev2beta3.ApisixTls{
@@ -86,29 +93,49 @@ func (t *translator) translateIngressV1(ing *networkingv1.Ingress) (*TranslateCo
 				ctx.addUpstream(ups)
 			}
 			uris := []string{pathRule.Path}
-			if pathRule.PathType != nil && *pathRule.PathType == networkingv1.PathTypePrefix {
-				// As per the specification of Ingress path matching rule:
-				// if the last element of the path is a substring of the
-				// last element in request path, it is not a match, e.g. /foo/bar
-				// matches /foo/bar/baz, but does not match /foo/barbaz.
-				// While in APISIX, /foo/bar matches both /foo/bar/baz and
-				// /foo/barbaz.
-				// In order to be conformant with Ingress specification, here
-				// we create two paths here, the first is the path itself
-				// (exact match), the other is path + "/*" (prefix match).
-				prefix := pathRule.Path
-				if strings.HasSuffix(prefix, "/") {
-					prefix += "*"
-				} else {
-					prefix += "/*"
+			var nginxVars []kubev2beta3.ApisixRouteHTTPMatchExpr
+			if pathRule.PathType != nil {
+				if *pathRule.PathType == networkingv1.PathTypePrefix {
+					// As per the specification of Ingress path matching rule:
+					// if the last element of the path is a substring of the
+					// last element in request path, it is not a match, e.g. /foo/bar
+					// matches /foo/bar/baz, but does not match /foo/barbaz.
+					// While in APISIX, /foo/bar matches both /foo/bar/baz and
+					// /foo/barbaz.
+					// In order to be conformant with Ingress specification, here
+					// we create two paths here, the first is the path itself
+					// (exact match), the other is path + "/*" (prefix match).
+					prefix := pathRule.Path
+					if strings.HasSuffix(prefix, "/") {
+						prefix += "*"
+					} else {
+						prefix += "/*"
+					}
+					uris = append(uris, prefix)
+				} else if *pathRule.PathType == networkingv1.PathTypeImplementationSpecific && useRegex {
+					nginxVars = append(nginxVars, kubev2beta3.ApisixRouteHTTPMatchExpr{
+						Subject: kubev2beta3.ApisixRouteHTTPMatchExprSubject{
+							Scope: apisixconst.ScopePath,
+						},
+						Op:    apisixconst.OpRegexMatch,
+						Value: &pathRule.Path,
+					})
+					uris = []string{"/*"}
 				}
-				uris = append(uris, prefix)
 			}
 			route := apisixv1.NewDefaultRoute()
 			route.Name = composeIngressRouteName(rule.Host, pathRule.Path)
 			route.ID = id.GenID(route.Name)
 			route.Host = rule.Host
 			route.Uris = uris
+			if len(nginxVars) > 0 {
+				routeVars, err := t.translateRouteMatchExprs(nginxVars)
+				if err != nil {
+					return nil, err
+				}
+				route.Vars = routeVars
+				route.Priority = _regexPriority
+			}
 			if len(plugins) > 0 {
 				route.Plugins = *(plugins.DeepCopy())
 			}
@@ -126,6 +153,8 @@ func (t *translator) translateIngressV1beta1(ing *networkingv1beta1.Ingress) (*T
 		upstreamMap: make(map[string]struct{}),
 	}
 	plugins := t.translateAnnotations(ing.Annotations)
+	annoExtractor := annotations.NewExtractor(ing.Annotations)
+	useRegex := annoExtractor.GetBoolAnnotation(annotations.AnnotationsPrefix + "use-regex")
 	// add https
 	for _, tls := range ing.Spec.TLS {
 		apisixTls := kubev2beta3.ApisixTls{
@@ -174,29 +203,49 @@ func (t *translator) translateIngressV1beta1(ing *networkingv1beta1.Ingress) (*T
 				ctx.addUpstream(ups)
 			}
 			uris := []string{pathRule.Path}
-			if pathRule.PathType != nil && *pathRule.PathType == networkingv1beta1.PathTypePrefix {
-				// As per the specification of Ingress path matching rule:
-				// if the last element of the path is a substring of the
-				// last element in request path, it is not a match, e.g. /foo/bar
-				// matches /foo/bar/baz, but does not match /foo/barbaz.
-				// While in APISIX, /foo/bar matches both /foo/bar/baz and
-				// /foo/barbaz.
-				// In order to be conformant with Ingress specification, here
-				// we create two paths here, the first is the path itself
-				// (exact match), the other is path + "/*" (prefix match).
-				prefix := pathRule.Path
-				if strings.HasSuffix(prefix, "/") {
-					prefix += "*"
-				} else {
-					prefix += "/*"
+			var nginxVars []kubev2beta3.ApisixRouteHTTPMatchExpr
+			if pathRule.PathType != nil {
+				if *pathRule.PathType == networkingv1beta1.PathTypePrefix {
+					// As per the specification of Ingress path matching rule:
+					// if the last element of the path is a substring of the
+					// last element in request path, it is not a match, e.g. /foo/bar
+					// matches /foo/bar/baz, but does not match /foo/barbaz.
+					// While in APISIX, /foo/bar matches both /foo/bar/baz and
+					// /foo/barbaz.
+					// In order to be conformant with Ingress specification, here
+					// we create two paths here, the first is the path itself
+					// (exact match), the other is path + "/*" (prefix match).
+					prefix := pathRule.Path
+					if strings.HasSuffix(prefix, "/") {
+						prefix += "*"
+					} else {
+						prefix += "/*"
+					}
+					uris = append(uris, prefix)
+				} else if *pathRule.PathType == networkingv1beta1.PathTypeImplementationSpecific && useRegex {
+					nginxVars = append(nginxVars, kubev2beta3.ApisixRouteHTTPMatchExpr{
+						Subject: kubev2beta3.ApisixRouteHTTPMatchExprSubject{
+							Scope: apisixconst.ScopePath,
+						},
+						Op:    apisixconst.OpRegexMatch,
+						Value: &pathRule.Path,
+					})
+					uris = []string{"/*"}
 				}
-				uris = append(uris, prefix)
 			}
 			route := apisixv1.NewDefaultRoute()
 			route.Name = composeIngressRouteName(rule.Host, pathRule.Path)
 			route.ID = id.GenID(route.Name)
 			route.Host = rule.Host
 			route.Uris = uris
+			if len(nginxVars) > 0 {
+				routeVars, err := t.translateRouteMatchExprs(nginxVars)
+				if err != nil {
+					return nil, err
+				}
+				route.Vars = routeVars
+				route.Priority = _regexPriority
+			}
 			if len(plugins) > 0 {
 				route.Plugins = *(plugins.DeepCopy())
 			}
@@ -245,6 +294,8 @@ func (t *translator) translateIngressExtensionsV1beta1(ing *extensionsv1beta1.In
 		upstreamMap: make(map[string]struct{}),
 	}
 	plugins := t.translateAnnotations(ing.Annotations)
+	annoExtractor := annotations.NewExtractor(ing.Annotations)
+	useRegex := annoExtractor.GetBoolAnnotation(annotations.AnnotationsPrefix + "use-regex")
 
 	for _, rule := range ing.Spec.Rules {
 		for _, pathRule := range rule.HTTP.Paths {
@@ -265,29 +316,49 @@ func (t *translator) translateIngressExtensionsV1beta1(ing *extensionsv1beta1.In
 				ctx.addUpstream(ups)
 			}
 			uris := []string{pathRule.Path}
-			if pathRule.PathType != nil && *pathRule.PathType == extensionsv1beta1.PathTypePrefix {
-				// As per the specification of Ingress path matching rule:
-				// if the last element of the path is a substring of the
-				// last element in request path, it is not a match, e.g. /foo/bar
-				// matches /foo/bar/baz, but does not match /foo/barbaz.
-				// While in APISIX, /foo/bar matches both /foo/bar/baz and
-				// /foo/barbaz.
-				// In order to be conformant with Ingress specification, here
-				// we create two paths here, the first is the path itself
-				// (exact match), the other is path + "/*" (prefix match).
-				prefix := pathRule.Path
-				if strings.HasSuffix(prefix, "/") {
-					prefix += "*"
-				} else {
-					prefix += "/*"
+			var nginxVars []kubev2beta3.ApisixRouteHTTPMatchExpr
+			if pathRule.PathType != nil {
+				if *pathRule.PathType == extensionsv1beta1.PathTypePrefix {
+					// As per the specification of Ingress path matching rule:
+					// if the last element of the path is a substring of the
+					// last element in request path, it is not a match, e.g. /foo/bar
+					// matches /foo/bar/baz, but does not match /foo/barbaz.
+					// While in APISIX, /foo/bar matches both /foo/bar/baz and
+					// /foo/barbaz.
+					// In order to be conformant with Ingress specification, here
+					// we create two paths here, the first is the path itself
+					// (exact match), the other is path + "/*" (prefix match).
+					prefix := pathRule.Path
+					if strings.HasSuffix(prefix, "/") {
+						prefix += "*"
+					} else {
+						prefix += "/*"
+					}
+					uris = append(uris, prefix)
+				} else if *pathRule.PathType == extensionsv1beta1.PathTypeImplementationSpecific && useRegex {
+					nginxVars = append(nginxVars, kubev2beta3.ApisixRouteHTTPMatchExpr{
+						Subject: kubev2beta3.ApisixRouteHTTPMatchExprSubject{
+							Scope: apisixconst.ScopePath,
+						},
+						Op:    apisixconst.OpRegexMatch,
+						Value: &pathRule.Path,
+					})
+					uris = []string{"/*"}
 				}
-				uris = append(uris, prefix)
 			}
 			route := apisixv1.NewDefaultRoute()
 			route.Name = composeIngressRouteName(rule.Host, pathRule.Path)
 			route.ID = id.GenID(route.Name)
 			route.Host = rule.Host
 			route.Uris = uris
+			if len(nginxVars) > 0 {
+				routeVars, err := t.translateRouteMatchExprs(nginxVars)
+				if err != nil {
+					return nil, err
+				}
+				route.Vars = routeVars
+				route.Priority = _regexPriority
+			}
 			if len(plugins) > 0 {
 				route.Plugins = *(plugins.DeepCopy())
 			}