diff --git a/docs/user-guide/nginx-configuration/annotations.md b/docs/user-guide/nginx-configuration/annotations.md index 56551b4e6..0ca62be34 100644 --- a/docs/user-guide/nginx-configuration/annotations.md +++ b/docs/user-guide/nginx-configuration/annotations.md @@ -43,6 +43,7 @@ You can add these Kubernetes annotations to specific Ingress objects to customiz |[nginx.ingress.kubernetes.io/limit-connections](#rate-limiting)|number| |[nginx.ingress.kubernetes.io/limit-rps](#rate-limiting)|number| |[nginx.ingress.kubernetes.io/permanent-redirect](#permanent-redirect)|string| +|[nginx.ingress.kubernetes.io/permanent-redirect-code](#permanent-redirect-code)|number| |[nginx.ingress.kubernetes.io/proxy-body-size](#custom-max-body-size)|string| |[nginx.ingress.kubernetes.io/proxy-cookie-domain](#proxy-cookie-domain)|string| |[nginx.ingress.kubernetes.io/proxy-connect-timeout](#custom-timeouts)|number| @@ -366,6 +367,10 @@ To configure this setting globally for all Ingress rules, the `limit-rate-after` This annotation allows to return a permanent redirect instead of sending data to the upstream. For example `nginx.ingress.kubernetes.io/permanent-redirect: https://www.google.com` would redirect everything to Google. +### Permanent Redirect Code + +This annotation allows you to modify the status code used for permanent redirects. For example `nginx.ingress.kubernetes.io/permanent-redirect-code: '308'` would return your permanet-redirect with a 308. + ### SSL Passthrough The annotation `nginx.ingress.kubernetes.io/ssl-passthrough` allows to configure TLS termination in the pod and not in NGINX. diff --git a/internal/ingress/annotations/redirect/redirect.go b/internal/ingress/annotations/redirect/redirect.go index d94ede184..52b540974 100644 --- a/internal/ingress/annotations/redirect/redirect.go +++ b/internal/ingress/annotations/redirect/redirect.go @@ -28,6 +28,8 @@ import ( "k8s.io/ingress-nginx/internal/ingress/resolver" ) +const defaultPermanentRedirectCode = http.StatusMovedPermanently + // Config returns the redirect configuration for an Ingress rule type Config struct { URL string `json:"url"` @@ -48,7 +50,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation { // rule used to create a redirect in the paths defined in the rule. // If the Ingress contains both annotations the execution order is // temporal and then permanent -func (a redirect) Parse(ing *extensions.Ingress) (interface{}, error) { +func (r redirect) Parse(ing *extensions.Ingress) (interface{}, error) { r3w, _ := parser.GetBoolAnnotation("from-to-www-redirect", ing) tr, err := parser.GetStringAnnotation("temporal-redirect", ing) @@ -73,20 +75,19 @@ func (a redirect) Parse(ing *extensions.Ingress) (interface{}, error) { return nil, err } - if pr != "" { - if err := isValidURL(pr); err != nil { - return nil, err - } - - return &Config{ - URL: pr, - Code: http.StatusMovedPermanently, - FromToWWW: r3w, - }, nil + prc, err := parser.GetIntAnnotation("permanent-redirect-code", ing) + if err != nil && !errors.IsMissingAnnotations(err) { + return nil, err } - if r3w { + if prc < http.StatusMultipleChoices || prc > http.StatusPermanentRedirect { + prc = defaultPermanentRedirectCode + } + + if pr != "" || r3w { return &Config{ + URL: pr, + Code: prc, FromToWWW: r3w, }, nil } diff --git a/internal/ingress/annotations/redirect/redirect_test.go b/internal/ingress/annotations/redirect/redirect_test.go new file mode 100644 index 000000000..6c60341aa --- /dev/null +++ b/internal/ingress/annotations/redirect/redirect_test.go @@ -0,0 +1,101 @@ +/* +Copyright 2018 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package redirect + +import ( + "net/http" + "strconv" + "testing" + + extensions "k8s.io/api/extensions/v1beta1" + + "k8s.io/ingress-nginx/internal/ingress/annotations/parser" + "k8s.io/ingress-nginx/internal/ingress/resolver" +) + +const ( + defRedirectURL = "http://some-site.com" +) + +func TestPermanentRedirectWithDefaultCode(t *testing.T) { + rp := NewParser(resolver.Mock{}) + if rp == nil { + t.Fatalf("Expected a parser.IngressAnnotation but returned nil") + } + + ing := new(extensions.Ingress) + + data := make(map[string]string, 1) + data[parser.GetAnnotationWithPrefix("permanent-redirect")] = defRedirectURL + ing.SetAnnotations(data) + + i, err := rp.Parse(ing) + if err != nil { + t.Errorf("Unexpected error with ingress: %v", err) + } + redirect, ok := i.(*Config) + if !ok { + t.Errorf("Expected a Redirect type") + } + if redirect.URL != defRedirectURL { + t.Errorf("Expected %v as redirect but returned %s", defRedirectURL, redirect.URL) + } + if redirect.Code != defaultPermanentRedirectCode { + t.Errorf("Expected %v as redirect to have a code %d but had %d", defRedirectURL, defaultPermanentRedirectCode, redirect.Code) + } +} + +func TestPermanentRedirectWithCustomCode(t *testing.T) { + rp := NewParser(resolver.Mock{}) + if rp == nil { + t.Fatalf("Expected a parser.IngressAnnotation but returned nil") + } + + testCases := map[string]struct { + input int + expectOutput int + }{ + "valid code": {http.StatusPermanentRedirect, http.StatusPermanentRedirect}, + "invalid code": {http.StatusTeapot, defaultPermanentRedirectCode}, + } + + for n, tc := range testCases { + t.Run(n, func(t *testing.T) { + ing := new(extensions.Ingress) + + data := make(map[string]string, 2) + data[parser.GetAnnotationWithPrefix("permanent-redirect")] = defRedirectURL + data[parser.GetAnnotationWithPrefix("permanent-redirect-code")] = strconv.Itoa(tc.input) + ing.SetAnnotations(data) + + i, err := rp.Parse(ing) + if err != nil { + t.Errorf("Unexpected error with ingress: %v", err) + } + redirect, ok := i.(*Config) + if !ok { + t.Errorf("Expected a redirect Config type") + } + if redirect.URL != defRedirectURL { + t.Errorf("Expected %v as redirect but returned %s", defRedirectURL, redirect.URL) + } + if redirect.Code != tc.expectOutput { + t.Errorf("Expected %v as redirect to have a code %d but had %d", defRedirectURL, tc.expectOutput, redirect.Code) + } + }) + } +} diff --git a/test/e2e/annotations/redirect.go b/test/e2e/annotations/redirect.go new file mode 100644 index 000000000..a2ce10d25 --- /dev/null +++ b/test/e2e/annotations/redirect.go @@ -0,0 +1,121 @@ +/* +Copyright 2018 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package annotations + +import ( + "fmt" + "net/http" + "strconv" + "strings" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "github.com/parnurzeal/gorequest" + + "k8s.io/ingress-nginx/test/e2e/framework" +) + +func noRedirectPolicyFunc(gorequest.Request, []gorequest.Request) error { + return http.ErrUseLastResponse +} + +var _ = framework.IngressNginxDescribe("Annotations - Redirect", func() { + f := framework.NewDefaultFramework("redirect") + + BeforeEach(func() { + }) + + AfterEach(func() { + }) + + It("should respond with a standard redirect code", func() { + By("setting permanent-redirect annotation") + + host := "redirect" + redirectPath := "/something" + redirectURL := "http://redirect.example.com" + + annotations := map[string]string{"nginx.ingress.kubernetes.io/permanent-redirect": redirectURL} + + ing := framework.NewSingleIngress(host, redirectPath, host, f.IngressController.Namespace, "http-svc", 80, &annotations) + _, err := f.EnsureIngress(ing) + + Expect(err).NotTo(HaveOccurred()) + Expect(ing).NotTo(BeNil()) + + err = f.WaitForNginxServer(host, + func(server string) bool { + return strings.Contains(server, fmt.Sprintf("if ($uri ~* %s) {", redirectPath)) && + strings.Contains(server, fmt.Sprintf("return 301 %s;", redirectURL)) + }) + Expect(err).NotTo(HaveOccurred()) + + By("sending request to redirected URL path") + + resp, body, errs := gorequest.New(). + Get(f.IngressController.HTTPURL+redirectPath). + Set("Host", host). + RedirectPolicy(noRedirectPolicyFunc). + End() + + Expect(errs).To(BeNil()) + Expect(resp.StatusCode).Should(BeNumerically("==", http.StatusMovedPermanently)) + Expect(resp.Header.Get("Location")).Should(Equal(redirectURL)) + Expect(body).Should(ContainSubstring("nginx/")) + }) + + It("should respond with a custom redirect code", func() { + By("setting permanent-redirect-code annotation") + + host := "redirect" + redirectPath := "/something" + redirectURL := "http://redirect.example.com" + redirectCode := http.StatusFound + + annotations := map[string]string{ + "nginx.ingress.kubernetes.io/permanent-redirect": redirectURL, + "nginx.ingress.kubernetes.io/permanent-redirect-code": strconv.Itoa(redirectCode), + } + + ing := framework.NewSingleIngress(host, redirectPath, host, f.IngressController.Namespace, "http-svc", 80, &annotations) + _, err := f.EnsureIngress(ing) + + Expect(err).NotTo(HaveOccurred()) + Expect(ing).NotTo(BeNil()) + + err = f.WaitForNginxServer(host, + func(server string) bool { + return strings.Contains(server, fmt.Sprintf("if ($uri ~* %s) {", redirectPath)) && + strings.Contains(server, fmt.Sprintf("return %d %s;", redirectCode, redirectURL)) + }) + Expect(err).NotTo(HaveOccurred()) + + By("sending request to redirected URL path") + + resp, body, errs := gorequest.New(). + Get(f.IngressController.HTTPURL+redirectPath). + Set("Host", host). + RedirectPolicy(noRedirectPolicyFunc). + End() + + Expect(errs).To(BeNil()) + Expect(resp.StatusCode).Should(BeNumerically("==", redirectCode)) + Expect(resp.Header.Get("Location")).Should(Equal(redirectURL)) + Expect(body).Should(ContainSubstring("nginx/")) + }) +})