Migrate to new networking.k8s.io/v1beta1 package

cmd/nginx/main.go

@@ -110,6 +110,11 @@ func main() {
 	conf.FakeCertificate = ssl.GetFakeSSLCert(fs)
 	klog.Infof("Created fake certificate with PemFileName: %v", conf.FakeCertificate.PemFileName)
 
+	k8s.IsNetworkingIngressAvailable = k8s.NetworkingIngressAvailable(kubeClient)
+	if !k8s.IsNetworkingIngressAvailable {
+		klog.Warningf("Using deprecated \"k8s.io/api/extensions/v1beta1\" package because Kubernetes version is < v1.14.0")
+	}
+
 	conf.Client = kubeClient
 
 	reg := prometheus.NewRegistry()

cmd/plugin/commands/backends/backends.go

@@ -18,6 +18,7 @@ package backends
 
 import (
 	"fmt"
+
 	"github.com/spf13/cobra"
 
 	"k8s.io/cli-runtime/pkg/genericclioptions"

cmd/plugin/commands/certs/certs.go

@@ -18,6 +18,7 @@ package certs
 
 import (
 	"fmt"
+
 	"github.com/spf13/cobra"
 
 	"k8s.io/cli-runtime/pkg/genericclioptions"

cmd/plugin/commands/conf/conf.go

@@ -18,9 +18,10 @@ package conf
 
 import (
 	"fmt"
-	"github.com/spf13/cobra"
 	"strings"
 
+	"github.com/spf13/cobra"
+
 	"k8s.io/cli-runtime/pkg/genericclioptions"
 
 	"k8s.io/ingress-nginx/cmd/plugin/kubectl"

cmd/plugin/commands/general/general.go

@@ -18,6 +18,7 @@ package general
 
 import (
 	"fmt"
+
 	"github.com/spf13/cobra"
 
 	"k8s.io/cli-runtime/pkg/genericclioptions"

cmd/plugin/commands/info/info.go

@@ -18,6 +18,7 @@ package info
 
 import (
 	"fmt"
+
 	"github.com/spf13/cobra"
 
 	"k8s.io/cli-runtime/pkg/genericclioptions"

cmd/plugin/commands/ingresses/ingresses.go

@@ -18,11 +18,11 @@ package ingresses
 
 import (
 	"fmt"
-	"github.com/spf13/cobra"
 	"os"
 	"text/tabwriter"
 
-	"k8s.io/api/extensions/v1beta1"
+	"github.com/spf13/cobra"
+	networking "k8s.io/api/networking/v1beta1"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
 
 	"k8s.io/ingress-nginx/cmd/plugin/request"
@@ -130,7 +130,7 @@ type ingressRow struct {
 	NumEndpoints string
 }
 
-func getIngressRows(ingresses *[]v1beta1.Ingress) []ingressRow {
+func getIngressRows(ingresses *[]networking.Ingress) []ingressRow {
 	rows := make([]ingressRow, 0)
 
 	for _, ing := range *ingresses {

cmd/plugin/commands/lint/main.go

@@ -22,10 +22,10 @@ import (
 	"github.com/spf13/cobra"
 
 	appsv1 "k8s.io/api/apps/v1"
-
+	networking "k8s.io/api/networking/v1beta1"
-	"k8s.io/api/extensions/v1beta1"
 	kmeta "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
+
 	"k8s.io/ingress-nginx/cmd/plugin/lints"
 	"k8s.io/ingress-nginx/cmd/plugin/request"
 	"k8s.io/ingress-nginx/cmd/plugin/util"
@@ -178,7 +178,7 @@ func checkObjectArray(lints []lint, objects []kmeta.Object, opts lintOptions) {
 }
 
 func ingresses(opts lintOptions) error {
-	var ings []v1beta1.Ingress
+	var ings []networking.Ingress
 	var err error
 	if opts.allNamespaces {
 		ings, err = request.GetIngressDefinitions(opts.flags, "")

cmd/plugin/commands/logs/logs.go

@@ -18,6 +18,7 @@ package logs
 
 import (
 	"fmt"
+
 	"github.com/spf13/cobra"
 
 	"k8s.io/cli-runtime/pkg/genericclioptions"

cmd/plugin/kubectl/kubectl.go

@@ -20,12 +20,13 @@ import (
 	"bytes"
 	"fmt"
 	"io"
-	apiv1 "k8s.io/api/core/v1"
-	"k8s.io/cli-runtime/pkg/genericclioptions"
 	"os"
 	"os/exec"
 	"strings"
 	"syscall"
+
+	apiv1 "k8s.io/api/core/v1"
+	"k8s.io/cli-runtime/pkg/genericclioptions"
 )
 
 // PodExecString takes a pod and a command, uses kubectl exec to run the command in the pod

cmd/plugin/lints/ingress.go

@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"strings"
 
-	"k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	kmeta "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/cmd/plugin/util"
 )
@@ -30,12 +30,12 @@ type IngressLint struct {
 	message string
 	issue   int
 	version string
-	f       func(ing v1beta1.Ingress) bool
+	f       func(ing networking.Ingress) bool
 }
 
 // Check returns true if the lint detects an issue
 func (lint IngressLint) Check(obj kmeta.Object) bool {
-	ing := obj.(*v1beta1.Ingress)
+	ing := obj.(*networking.Ingress)
 	return lint.f(*ing)
 }
 
@@ -87,7 +87,7 @@ func GetIngressLints() []IngressLint {
 	}
 }
 
-func xForwardedPrefixIsBool(ing v1beta1.Ingress) bool {
+func xForwardedPrefixIsBool(ing networking.Ingress) bool {
 	for name, val := range ing.Annotations {
 		if strings.HasSuffix(name, "/x-forwarded-prefix") && (val == "true" || val == "false") {
 			return true
@@ -96,7 +96,7 @@ func xForwardedPrefixIsBool(ing v1beta1.Ingress) bool {
 	return false
 }
 
-func annotationPrefixIsNginxCom(ing v1beta1.Ingress) bool {
+func annotationPrefixIsNginxCom(ing networking.Ingress) bool {
 	for name := range ing.Annotations {
 		if strings.HasPrefix(name, "nginx.com/") {
 			return true
@@ -105,7 +105,7 @@ func annotationPrefixIsNginxCom(ing v1beta1.Ingress) bool {
 	return false
 }
 
-func annotationPrefixIsNginxOrg(ing v1beta1.Ingress) bool {
+func annotationPrefixIsNginxOrg(ing networking.Ingress) bool {
 	for name := range ing.Annotations {
 		if strings.HasPrefix(name, "nginx.org/") {
 			return true
@@ -114,7 +114,7 @@ func annotationPrefixIsNginxOrg(ing v1beta1.Ingress) bool {
 	return false
 }
 
-func rewriteTargetWithoutCaptureGroup(ing v1beta1.Ingress) bool {
+func rewriteTargetWithoutCaptureGroup(ing networking.Ingress) bool {
 	for name, val := range ing.Annotations {
 		if strings.HasSuffix(name, "/rewrite-target") && !strings.Contains(val, "$1") {
 			return true
@@ -128,7 +128,7 @@ func removedAnnotation(annotationName string, issueNumber int, version string) I
 		message: fmt.Sprintf("Contains the removed %v annotation.", annotationName),
 		issue:   issueNumber,
 		version: version,
-		f: func(ing v1beta1.Ingress) bool {
+		f: func(ing networking.Ingress) bool {
 			for annotation := range ing.Annotations {
 				if strings.HasSuffix(annotation, "/"+annotationName) {
 					return true

cmd/plugin/request/request.go

@@ -21,12 +21,13 @@ import (
 
 	appsv1 "k8s.io/api/apps/v1"
 	apiv1 "k8s.io/api/core/v1"
-	"k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
 	appsv1client "k8s.io/client-go/kubernetes/typed/apps/v1"
 	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
-	extensions "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
+	typednetworking "k8s.io/client-go/kubernetes/typed/networking/v1beta1"
+
 	"k8s.io/ingress-nginx/cmd/plugin/util"
 )
 
@@ -90,20 +91,20 @@ func GetDeployments(flags *genericclioptions.ConfigFlags, namespace string) ([]a
 }
 
 // GetIngressDefinitions returns an array of Ingress resource definitions
-func GetIngressDefinitions(flags *genericclioptions.ConfigFlags, namespace string) ([]v1beta1.Ingress, error) {
+func GetIngressDefinitions(flags *genericclioptions.ConfigFlags, namespace string) ([]networking.Ingress, error) {
 	rawConfig, err := flags.ToRESTConfig()
 	if err != nil {
-		return make([]v1beta1.Ingress, 0), err
+		return make([]networking.Ingress, 0), err
 	}
 
-	api, err := extensions.NewForConfig(rawConfig)
+	api, err := typednetworking.NewForConfig(rawConfig)
 	if err != nil {
-		return make([]v1beta1.Ingress, 0), err
+		return make([]networking.Ingress, 0), err
 	}
 
 	pods, err := api.Ingresses(namespace).List(metav1.ListOptions{})
 	if err != nil {
-		return make([]v1beta1.Ingress, 0), err
+		return make([]networking.Ingress, 0), err
 	}
 
 	return pods.Items, nil

deploy/cluster-wide/cluster-role.yaml

@@ -28,14 +28,6 @@ rules:
       - get
       - list
       - watch
-  - apiGroups:
-      - "extensions"
-    resources:
-      - ingresses
-    verbs:
-      - get
-      - list
-      - watch
   - apiGroups:
       - ""
     resources:
@@ -43,9 +35,31 @@ rules:
     verbs:
       - create
       - patch
+  - apiGroups:
+      - "extensions"
+    resources:
+      - ingresses
+    verbs:
+      - get
+      - list
+      - watch
   - apiGroups:
       - "extensions"
     resources:
       - ingresses/status
     verbs:
       - update
+  - apiGroups:
+      - "networking.k8s.io"
+    resources:
+      - ingresses
+    verbs:
+      - get
+      - list
+      - watch
+  - apiGroups:
+      - "networking.k8s.io"
+    resources:
+      - ingresses/status
+    verbs:
+      - update

docs/examples/auth/external-auth/README.md

@@ -23,7 +23,7 @@ metadata:
   name: external-auth
   namespace: default
   resourceVersion: "2068378"
-  selfLink: /apis/extensions/v1beta1/namespaces/default/ingresses/external-auth
+  selfLink: /apis/networking/v1beta1/namespaces/default/ingresses/external-auth
   uid: 5c388f1d-8970-11e6-9004-080027d2dc94
 spec:
   rules:

docs/troubleshooting.md

@@ -32,7 +32,7 @@ Rules:
             /tea      tea-svc:80 (<none>)
             /coffee   coffee-svc:80 (<none>)
 Annotations:
-  kubectl.kubernetes.io/last-applied-configuration:  {"apiVersion":"extensions/v1beta1","kind":"Ingress","metadata":{"annotations":{},"name":"cafe-ingress","namespace":"default","selfLink":"/apis/extensions/v1beta1/namespaces/default/ingresses/cafe-ingress"},"spec":{"rules":[{"host":"cafe.com","http":{"paths":[{"backend":{"serviceName":"tea-svc","servicePort":80},"path":"/tea"},{"backend":{"serviceName":"coffee-svc","servicePort":80},"path":"/coffee"}]}}]},"status":{"loadBalancer":{"ingress":[{"ip":"169.48.142.110"}]}}}
+  kubectl.kubernetes.io/last-applied-configuration:  {"apiVersion":"extensions/v1beta1","kind":"Ingress","metadata":{"annotations":{},"name":"cafe-ingress","namespace":"default","selfLink":"/apis/networking/v1beta1/namespaces/default/ingresses/cafe-ingress"},"spec":{"rules":[{"host":"cafe.com","http":{"paths":[{"backend":{"serviceName":"tea-svc","servicePort":80},"path":"/tea"},{"backend":{"serviceName":"coffee-svc","servicePort":80},"path":"/coffee"}]}}]},"status":{"loadBalancer":{"ingress":[{"ip":"169.48.142.110"}]}}}
 
 Events:
   Type    Reason  Age   From                      Message
@@ -218,8 +218,8 @@ $ kubectl exec test-701078429-s5kca -- curl --cacert /var/run/secrets/kubernetes
     "/apis/batch/v2alpha1",
     "/apis/certificates.k8s.io",
     "/apis/certificates.k8s.io/v1alpha1",
-    "/apis/extensions",
+    "/apis/networking",
-    "/apis/extensions/v1beta1",
+    "/apis/networking/v1beta1",
     "/apis/policy",
     "/apis/policy/v1alpha1",
     "/apis/rbac.authorization.k8s.io",

internal/admission/controller/main.go

@@ -19,8 +19,8 @@ package controller
 import (
 	"github.com/google/uuid"
 	"k8s.io/api/admission/v1beta1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/klog"
@@ -29,7 +29,7 @@ import (
 // Checker must return an error if the ingress provided as argument
 // contains invalid instructions
 type Checker interface {
-	CheckIngress(ing *extensions.Ingress) error
+	CheckIngress(ing *networking.Ingress) error
 }
 
 // IngressAdmission implements the AdmissionController interface
@@ -52,14 +52,14 @@ func (ia *IngressAdmission) HandleAdmission(ar *v1beta1.AdmissionReview) error {
 	}
 	klog.V(3).Infof("handling ingress admission webhook request for {%s}  %s in namespace %s", ar.Request.Resource.String(), ar.Request.Name, ar.Request.Namespace)
 
-	ingressResource := v1.GroupVersionResource{Group: extensions.SchemeGroupVersion.Group, Version: extensions.SchemeGroupVersion.Version, Resource: "ingresses"}
+	ingressResource := v1.GroupVersionResource{Group: networking.SchemeGroupVersion.Group, Version: networking.SchemeGroupVersion.Version, Resource: "ingresses"}
 
 	if ar.Request.Resource == ingressResource {
 		ar.Response = &v1beta1.AdmissionResponse{
 			UID:     types.UID(uuid.New().String()),
 			Allowed: false,
 		}
-		ingress := extensions.Ingress{}
+		ingress := networking.Ingress{}
 		deserializer := codecs.UniversalDeserializer()
 		if _, _, err := deserializer.Decode(ar.Request.Object.Raw, nil, &ingress); err != nil {
 			ar.Response.Result = &v1.Status{Message: err.Error()}

internal/admission/controller/main_test.go

@@ -21,8 +21,8 @@ import (
 	"testing"
 
 	"k8s.io/api/admission/v1beta1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/json"
 )
 
@@ -32,7 +32,7 @@ type failTestChecker struct {
 	t *testing.T
 }
 
-func (ftc failTestChecker) CheckIngress(ing *extensions.Ingress) error {
+func (ftc failTestChecker) CheckIngress(ing *networking.Ingress) error {
 	ftc.t.Error("checker should not be called")
 	return nil
 }
@@ -42,7 +42,7 @@ type testChecker struct {
 	err error
 }
 
-func (tc testChecker) CheckIngress(ing *extensions.Ingress) error {
+func (tc testChecker) CheckIngress(ing *networking.Ingress) error {
 	if ing.ObjectMeta.Name != testIngressName {
 		tc.t.Errorf("CheckIngress should be called with %v ingress, but got %v", testIngressName, ing.ObjectMeta.Name)
 	}
@@ -66,7 +66,7 @@ func TestHandleAdmission(t *testing.T) {
 		t.Errorf("with a non ingress resource, no error should be returned")
 	}
 
-	review.Request.Resource = v1.GroupVersionResource{Group: extensions.SchemeGroupVersion.Group, Version: extensions.SchemeGroupVersion.Version, Resource: "ingresses"}
+	review.Request.Resource = v1.GroupVersionResource{Group: networking.SchemeGroupVersion.Group, Version: networking.SchemeGroupVersion.Version, Resource: "ingresses"}
 	review.Request.Object.Raw = []byte{0xff}
 
 	err = adm.HandleAdmission(review)
@@ -77,7 +77,7 @@ func TestHandleAdmission(t *testing.T) {
 		t.Errorf("when the request object is not decodable, an error should be returned")
 	}
 
-	raw, err := json.Marshal(extensions.Ingress{ObjectMeta: v1.ObjectMeta{Name: testIngressName}})
+	raw, err := json.Marshal(networking.Ingress{ObjectMeta: v1.ObjectMeta{Name: testIngressName}})
 	if err != nil {
 		t.Errorf("failed to prepare test ingress data: %v", err.Error())
 	}

internal/ingress/annotations/alias/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package alias
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -34,6 +34,6 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // Parse parses the annotations contained in the ingress rule
 // used to add an alias to the provided hosts
-func (a alias) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a alias) Parse(ing *networking.Ingress) (interface{}, error) {
 	return parser.GetStringAnnotation("server-alias", ing)
 }

internal/ingress/annotations/alias/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -46,12 +46,12 @@ func TestParse(t *testing.T) {
 		{nil, ""},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	for _, testCase := range testCases {

internal/ingress/annotations/annotations.go

@@ -24,7 +24,7 @@ import (
 	"k8s.io/klog"
 
 	apiv1 "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/alias"
@@ -158,7 +158,7 @@ func NewAnnotationExtractor(cfg resolver.Resolver) Extractor {
 }
 
 // Extract extracts the annotations from an Ingress
-func (e Extractor) Extract(ing *extensions.Ingress) *Ingress {
+func (e Extractor) Extract(ing *networking.Ingress) *Ingress {
 	pia := &Ingress{
 		ObjectMeta: ing.ObjectMeta,
 	}

internal/ingress/annotations/annotations_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	apiv1 "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 
@@ -74,28 +74,28 @@ func (m mockCfg) GetAuthCertificate(name string) (*resolver.AuthSSLCert, error)
 	return nil, nil
 }
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "foo",
 			Namespace: apiv1.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/auth/main.go

@@ -23,7 +23,7 @@ import (
 
 	"github.com/pkg/errors"
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	"k8s.io/client-go/tools/cache"
 
 	"k8s.io/ingress-nginx/internal/file"
@@ -92,7 +92,7 @@ func NewParser(authDirectory string, r resolver.Resolver) parser.IngressAnnotati
 // rule used to add authentication in the paths defined in the rule
 // and generated an htpasswd compatible file to be used as source
 // during the authentication process
-func (a auth) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a auth) Parse(ing *networking.Ingress) (interface{}, error) {
 	at, err := parser.GetStringAnnotation("auth-type", ing)
 	if err != nil {
 		return nil, err

internal/ingress/annotations/auth/main_test.go

@@ -26,7 +26,7 @@ import (
 	"github.com/pkg/errors"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
@@ -34,28 +34,28 @@ import (
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/authreq/main.go

@@ -24,7 +24,7 @@ import (
 
 	"k8s.io/klog"
 
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	ing_errors "k8s.io/ingress-nginx/internal/ingress/errors"
@@ -115,7 +115,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // ParseAnnotations parses the annotations contained in the ingress
 // rule used to use an Config URL as source for authentication
-func (a authReq) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a authReq) Parse(ing *networking.Ingress) (interface{}, error) {
 	// Required Parameters
 	urlString, err := parser.GetStringAnnotation("auth-url", ing)
 	if err != nil {

internal/ingress/annotations/authreq/main_test.go

@@ -23,7 +23,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -31,28 +31,28 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/authreqglobal/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package authreqglobal
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -34,7 +34,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // ParseAnnotations parses the annotations contained in the ingress
 // rule used to enable or disable global external authentication
-func (a authReqGlobal) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a authReqGlobal) Parse(ing *networking.Ingress) (interface{}, error) {
 
 	enableGlobalAuth, err := parser.GetBoolAnnotation("enable-global-auth", ing)
 	if err != nil {

internal/ingress/annotations/authreqglobal/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -28,28 +28,28 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/authtls/main.go

@@ -18,7 +18,7 @@ package authtls
 
 import (
 	"github.com/pkg/errors"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"regexp"
 
@@ -86,7 +86,7 @@ type authTLS struct {
 
 // Parse parses the annotations contained in the ingress
 // rule used to use a Certificate as authentication method
-func (a authTLS) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a authTLS) Parse(ing *networking.Ingress) (interface{}, error) {
 	var err error
 	config := &Config{}
 

internal/ingress/annotations/authtls/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
@@ -28,28 +28,28 @@ import (
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/backendprotocol/main.go

@@ -20,7 +20,7 @@ import (
 	"regexp"
 	"strings"
 
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	"k8s.io/klog"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
@@ -45,7 +45,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // ParseAnnotations parses the annotations contained in the ingress
 // rule used to indicate the backend protocol.
-func (a backendProtocol) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a backendProtocol) Parse(ing *networking.Ingress) (interface{}, error) {
 	if ing.GetAnnotations() == nil {
 		return HTTP, nil
 	}

internal/ingress/annotations/backendprotocol/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -28,14 +28,14 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},

internal/ingress/annotations/canary/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package canary
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/errors"
@@ -44,7 +44,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // Parse parses the annotations contained in the ingress
 // rule used to indicate if the canary should be enabled and with what config
-func (c canary) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (c canary) Parse(ing *networking.Ingress) (interface{}, error) {
 	config := &Config{}
 	var err error
 

internal/ingress/annotations/canary/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
@@ -30,28 +30,28 @@ import (
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: metaV1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/class/main.go

@@ -17,8 +17,9 @@ limitations under the License.
 package class
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
 	"k8s.io/klog"
+
+	networking "k8s.io/api/networking/v1beta1"
 )
 
 const (
@@ -41,7 +42,7 @@ var (
 // IsValid returns true if the given Ingress either doesn't specify
 // the ingress.class annotation, or it's set to the configured in the
 // ingress controller.
-func IsValid(ing *extensions.Ingress) bool {
+func IsValid(ing *networking.Ingress) bool {
 	ingress, ok := ing.GetAnnotations()[IngressKey]
 	if !ok {
 		klog.V(3).Infof("annotation %v is not present in ingress %v/%v", IngressKey, ing.Namespace, ing.Name)

internal/ingress/annotations/class/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
@@ -47,7 +47,7 @@ func TestIsValidClass(t *testing.T) {
 		{"custom", "nginx", "nginx", false},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,

internal/ingress/annotations/clientbodybuffersize/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package clientbodybuffersize
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -34,6 +34,6 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // Parse parses the annotations contained in the ingress rule
 // used to add an client-body-buffer-size to the provided locations
-func (cbbs clientBodyBufferSize) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (cbbs clientBodyBufferSize) Parse(ing *networking.Ingress) (interface{}, error) {
 	return parser.GetStringAnnotation("client-body-buffer-size", ing)
 }

internal/ingress/annotations/clientbodybuffersize/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -44,12 +44,12 @@ func TestParse(t *testing.T) {
 		{nil, ""},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	for _, testCase := range testCases {

internal/ingress/annotations/connection/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package connection
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -40,7 +40,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // Parse parses the annotations contained in the ingress
 // rule used to indicate if the connection header should be overridden.
-func (a connection) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a connection) Parse(ing *networking.Ingress) (interface{}, error) {
 	cp, err := parser.GetStringAnnotation("connection-proxy-header", ing)
 	if err != nil {
 		return &Config{

internal/ingress/annotations/connection/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -43,12 +43,12 @@ func TestParse(t *testing.T) {
 		{nil, &Config{Enabled: false}},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	for _, testCase := range testCases {

internal/ingress/annotations/cors/main.go

@@ -19,7 +19,7 @@ package cors
 import (
 	"regexp"
 
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -96,7 +96,7 @@ func (c1 *Config) Equal(c2 *Config) bool {
 
 // Parse parses the annotations contained in the ingress
 // rule used to indicate if the location/s should allows CORS
-func (c cors) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (c cors) Parse(ing *networking.Ingress) (interface{}, error) {
 	var err error
 	config := &Config{}
 

internal/ingress/annotations/cors/main_test.go

@@ -20,35 +20,35 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/customhttperrors/main.go

@@ -20,7 +20,7 @@ import (
 	"strconv"
 	"strings"
 
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -37,7 +37,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // Parse parses the annotations contained in the ingress to use
 // custom http errors
-func (e customhttperrors) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (e customhttperrors) Parse(ing *networking.Ingress) (interface{}, error) {
 	c, err := parser.GetStringAnnotation("custom-http-errors", ing)
 	if err != nil {
 		return nil, err

internal/ingress/annotations/customhttperrors/main_test.go

@@ -22,7 +22,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -30,14 +30,14 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},

internal/ingress/annotations/defaultbackend/main.go

@@ -20,7 +20,7 @@ import (
 	"fmt"
 
 	"github.com/pkg/errors"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -37,7 +37,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // Parse parses the annotations contained in the ingress to use
 // a custom default backend
-func (db backend) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (db backend) Parse(ing *networking.Ingress) (interface{}, error) {
 	s, err := parser.GetStringAnnotation("default-backend", ing)
 	if err != nil {
 		return nil, err

internal/ingress/annotations/defaultbackend/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/errors"
@@ -29,28 +29,28 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/http2pushpreload/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package http2pushpreload
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -34,6 +34,6 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // Parse parses the annotations contained in the ingress rule
 // used to add http2 push preload to the server
-func (h2pp http2PushPreload) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (h2pp http2PushPreload) Parse(ing *networking.Ingress) (interface{}, error) {
 	return parser.GetBoolAnnotation("http2-push-preload", ing)
 }

internal/ingress/annotations/http2pushpreload/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -44,12 +44,12 @@ func TestParse(t *testing.T) {
 		{nil, false},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	for _, testCase := range testCases {

internal/ingress/annotations/influxdb/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package influxdb
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -42,7 +42,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 }
 
 // Parse parses the annotations to look for InfluxDB configurations
-func (c influxdb) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (c influxdb) Parse(ing *networking.Ingress) (interface{}, error) {
 	var err error
 	config := &Config{}
 

internal/ingress/annotations/influxdb/main_test.go

@@ -20,35 +20,35 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/ipwhitelist/main.go

@@ -22,7 +22,7 @@ import (
 
 	"github.com/pkg/errors"
 
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	"k8s.io/ingress-nginx/internal/net"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
@@ -66,7 +66,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 // rule used to limit access to certain client addresses or networks.
 // Multiple ranges can specified using commas as separator
 // e.g. `18.0.0.0/8,56.0.0.0/8`
-func (a ipwhitelist) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a ipwhitelist) Parse(ing *networking.Ingress) (interface{}, error) {
 	defBackend := a.r.GetDefaultBackend()
 	sort.Strings(defBackend.WhitelistSourceRange)
 

internal/ingress/annotations/ipwhitelist/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
@@ -28,28 +28,28 @@ import (
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/loadbalancing/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package loadbalancing
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -35,6 +35,6 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 // Parse parses the annotations contained in the ingress rule
 // used to indicate if the location/s contains a fragment of
 // configuration to be included inside the paths of the rules
-func (a loadbalancing) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a loadbalancing) Parse(ing *networking.Ingress) (interface{}, error) {
 	return parser.GetStringAnnotation("load-balance", ing)
 }

internal/ingress/annotations/loadbalancing/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -43,12 +43,12 @@ func TestParse(t *testing.T) {
 		{nil, ""},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	for _, testCase := range testCases {

internal/ingress/annotations/log/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package log
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -53,7 +53,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // Parse parses the annotations contained in the ingress
 // rule used to indicate if the location/s should enable logs
-func (l log) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (l log) Parse(ing *networking.Ingress) (interface{}, error) {
 	var err error
 	config := &Config{}
 

internal/ingress/annotations/log/main_test.go

@@ -20,35 +20,35 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/luarestywaf/main.go

@@ -19,7 +19,7 @@ package luarestywaf
 import (
 	"strings"
 
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/errors"
@@ -88,7 +88,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 // Parse parses the annotations contained in the ingress rule
 // used to indicate if the location/s contains a fragment of
 // configuration to be included inside the paths of the rules
-func (a luarestywaf) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a luarestywaf) Parse(ing *networking.Ingress) (interface{}, error) {
 	var err error
 	config := &Config{}
 

internal/ingress/annotations/luarestywaf/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -67,12 +67,12 @@ func TestParse(t *testing.T) {
 		{map[string]string{luaRestyWAFAnnotation: "active", luaRestyWAFProcessMultipartBody: "false"}, &Config{Mode: "ACTIVE", ProcessMultipartBody: false, IgnoredRuleSets: []string{}}},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	for _, testCase := range testCases {

internal/ingress/annotations/modsecurity/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package modsecurity
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
@@ -65,7 +65,7 @@ type modSecurity struct {
 
 // Parse parses the annotations contained in the ingress
 // rule used to enable ModSecurity in a particular location
-func (a modSecurity) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a modSecurity) Parse(ing *networking.Ingress) (interface{}, error) {
 	var err error
 	config := &Config{}
 

internal/ingress/annotations/modsecurity/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -59,12 +59,12 @@ func TestParse(t *testing.T) {
 		{nil, Config{false, false, "", ""}},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	for _, testCase := range testCases {

internal/ingress/annotations/parser/main.go

@@ -21,7 +21,7 @@ import (
 	"strconv"
 	"strings"
 
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/errors"
 )
@@ -33,7 +33,7 @@ var (
 
 // IngressAnnotation has a method to parse annotations located in Ingress
 type IngressAnnotation interface {
-	Parse(ing *extensions.Ingress) (interface{}, error)
+	Parse(ing *networking.Ingress) (interface{}, error)
 }
 
 type ingAnnotations map[string]string
@@ -75,7 +75,7 @@ func (a ingAnnotations) parseInt(name string) (int, error) {
 	return 0, errors.ErrMissingAnnotations
 }
 
-func checkAnnotation(name string, ing *extensions.Ingress) error {
+func checkAnnotation(name string, ing *networking.Ingress) error {
 	if ing == nil || len(ing.GetAnnotations()) == 0 {
 		return errors.ErrMissingAnnotations
 	}
@@ -87,7 +87,7 @@ func checkAnnotation(name string, ing *extensions.Ingress) error {
 }
 
 // GetBoolAnnotation extracts a boolean from an Ingress annotation
-func GetBoolAnnotation(name string, ing *extensions.Ingress) (bool, error) {
+func GetBoolAnnotation(name string, ing *networking.Ingress) (bool, error) {
 	v := GetAnnotationWithPrefix(name)
 	err := checkAnnotation(v, ing)
 	if err != nil {
@@ -97,7 +97,7 @@ func GetBoolAnnotation(name string, ing *extensions.Ingress) (bool, error) {
 }
 
 // GetStringAnnotation extracts a string from an Ingress annotation
-func GetStringAnnotation(name string, ing *extensions.Ingress) (string, error) {
+func GetStringAnnotation(name string, ing *networking.Ingress) (string, error) {
 	v := GetAnnotationWithPrefix(name)
 	err := checkAnnotation(v, ing)
 	if err != nil {
@@ -108,7 +108,7 @@ func GetStringAnnotation(name string, ing *extensions.Ingress) (string, error) {
 }
 
 // GetIntAnnotation extracts an int from an Ingress annotation
-func GetIntAnnotation(name string, ing *extensions.Ingress) (int, error) {
+func GetIntAnnotation(name string, ing *networking.Ingress) (int, error) {
 	v := GetAnnotationWithPrefix(name)
 	err := checkAnnotation(v, ing)
 	if err != nil {

internal/ingress/annotations/parser/main_test.go

@@ -20,17 +20,17 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 }
 

internal/ingress/annotations/portinredirect/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package portinredirect
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -34,7 +34,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // Parse parses the annotations contained in the ingress
 // rule used to indicate if the redirects must
-func (a portInRedirect) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a portInRedirect) Parse(ing *networking.Ingress) (interface{}, error) {
 	up, err := parser.GetBoolAnnotation("use-port-in-redirects", ing)
 	if err != nil {
 		return a.r.GetDefaultBackend().UsePortInRedirects, nil

internal/ingress/annotations/portinredirect/main_test.go

@@ -21,7 +21,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 
@@ -30,28 +30,28 @@ import (
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/proxy/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package proxy
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -110,7 +110,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // ParseAnnotations parses the annotations contained in the ingress
 // rule used to configure upstream check parameters
-func (a proxy) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a proxy) Parse(ing *networking.Ingress) (interface{}, error) {
 	defBackend := a.r.GetDefaultBackend()
 	config := &Config{}
 

internal/ingress/annotations/proxy/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 
@@ -29,28 +29,28 @@ import (
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/ratelimit/main.go

@@ -22,7 +22,7 @@ import (
 	"sort"
 	"strings"
 
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -148,7 +148,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // ParseAnnotations parses the annotations contained in the ingress
 // rule used to rewrite the defined paths
-func (a ratelimit) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a ratelimit) Parse(ing *networking.Ingress) (interface{}, error) {
 	defBackend := a.r.GetDefaultBackend()
 	lr, err := parser.GetIntAnnotation("limit-rate", ing)
 	if err != nil {

internal/ingress/annotations/ratelimit/main_test.go

@@ -22,7 +22,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"k8s.io/apimachinery/pkg/util/intstr"
@@ -31,28 +31,28 @@ import (
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/redirect/redirect.go

@@ -21,7 +21,7 @@ import (
 	"net/url"
 	"strings"
 
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/errors"
@@ -50,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 (r redirect) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (r redirect) Parse(ing *networking.Ingress) (interface{}, error) {
 	r3w, _ := parser.GetBoolAnnotation("from-to-www-redirect", ing)
 
 	tr, err := parser.GetStringAnnotation("temporal-redirect", ing)

internal/ingress/annotations/redirect/redirect_test.go

@@ -23,7 +23,7 @@ import (
 	"strconv"
 	"testing"
 
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/errors"
@@ -40,7 +40,7 @@ func TestPermanentRedirectWithDefaultCode(t *testing.T) {
 		t.Fatalf("Expected a parser.IngressAnnotation but returned nil")
 	}
 
-	ing := new(extensions.Ingress)
+	ing := new(networking.Ingress)
 
 	data := make(map[string]string, 1)
 	data[parser.GetAnnotationWithPrefix("permanent-redirect")] = defRedirectURL
@@ -78,7 +78,7 @@ func TestPermanentRedirectWithCustomCode(t *testing.T) {
 
 	for n, tc := range testCases {
 		t.Run(n, func(t *testing.T) {
-			ing := new(extensions.Ingress)
+			ing := new(networking.Ingress)
 
 			data := make(map[string]string, 2)
 			data[parser.GetAnnotationWithPrefix("permanent-redirect")] = defRedirectURL
@@ -109,7 +109,7 @@ func TestTemporalRedirect(t *testing.T) {
 		t.Fatalf("Expected a parser.IngressAnnotation but returned nil")
 	}
 
-	ing := new(extensions.Ingress)
+	ing := new(networking.Ingress)
 
 	data := make(map[string]string, 1)
 	data[parser.GetAnnotationWithPrefix("from-to-www-redirect")] = "true"

internal/ingress/annotations/rewrite/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package rewrite
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -75,7 +75,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // ParseAnnotations parses the annotations contained in the ingress
 // rule used to rewrite the defined paths
-func (a rewrite) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a rewrite) Parse(ing *networking.Ingress) (interface{}, error) {
 	var err error
 	config := &Config{}
 

internal/ingress/annotations/rewrite/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 
@@ -33,28 +33,28 @@ const (
 	defRoute = "/demo"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/satisfy/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package satisfy
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -33,7 +33,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 }
 
 // Parse parses annotation contained in the ingress
-func (s satisfy) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (s satisfy) Parse(ing *networking.Ingress) (interface{}, error) {
 	satisfy, err := parser.GetStringAnnotation("satisfy", ing)
 
 	if err != nil || (satisfy != "any" && satisfy != "all") {

internal/ingress/annotations/satisfy/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"k8s.io/apimachinery/pkg/util/intstr"
@@ -28,28 +28,28 @@ import (
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "fake",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "fake.host.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/fake",
 									Backend: defaultBackend,

internal/ingress/annotations/secureupstream/main.go

@@ -20,7 +20,7 @@ import (
 	"fmt"
 
 	"github.com/pkg/errors"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -42,7 +42,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // Parse parses the annotations contained in the ingress
 // rule used to indicate if the upstream servers should use SSL
-func (a su) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a su) Parse(ing *networking.Ingress) (interface{}, error) {
 	bp, _ := parser.GetStringAnnotation("backend-protocol", ing)
 	ca, _ := parser.GetStringAnnotation("secure-verify-ca-secret", ing)
 	secure := &Config{

internal/ingress/annotations/secureupstream/main_test.go

@@ -21,7 +21,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"k8s.io/apimachinery/pkg/util/intstr"
@@ -29,28 +29,28 @@ import (
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/serversnippet/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package serversnippet
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -35,6 +35,6 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 // Parse parses the annotations contained in the ingress rule
 // used to indicate if the location/s contains a fragment of
 // configuration to be included inside the paths of the rules
-func (a serverSnippet) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a serverSnippet) Parse(ing *networking.Ingress) (interface{}, error) {
 	return parser.GetStringAnnotation("server-snippet", ing)
 }

internal/ingress/annotations/serversnippet/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -44,12 +44,12 @@ func TestParse(t *testing.T) {
 		{nil, ""},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	for _, testCase := range testCases {

internal/ingress/annotations/serviceupstream/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package serviceupstream
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -32,6 +32,6 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 	return serviceUpstream{r}
 }
 
-func (s serviceUpstream) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (s serviceUpstream) Parse(ing *networking.Ingress) (interface{}, error) {
 	return parser.GetBoolAnnotation("service-upstream", ing)
 }

internal/ingress/annotations/serviceupstream/main_test.go

@@ -20,35 +20,35 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,

internal/ingress/annotations/sessionaffinity/main.go

@@ -19,7 +19,7 @@ package sessionaffinity
 import (
 	"regexp"
 
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	"k8s.io/klog"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
@@ -76,7 +76,7 @@ type Cookie struct {
 
 // cookieAffinityParse gets the annotation values related to Cookie Affinity
 // It also sets default values when no value or incorrect value is found
-func (a affinity) cookieAffinityParse(ing *extensions.Ingress) *Cookie {
+func (a affinity) cookieAffinityParse(ing *networking.Ingress) *Cookie {
 	var err error
 
 	cookie := &Cookie{}
@@ -109,6 +109,11 @@ func (a affinity) cookieAffinityParse(ing *extensions.Ingress) *Cookie {
 		klog.V(3).Infof("Invalid or no annotation value found in Ingress %v: %v. Ignoring it", ing.Name, annotationAffinityCookieChangeOnFailure)
 	}
 
+	cookie.ChangeOnFailure, err = parser.GetBoolAnnotation(annotationAffinityCookieChangeOnFailure, ing)
+	if err != nil {
+		klog.V(3).Infof("Invalid or no annotation value found in Ingress %v: %v. Ignoring it", ing.Name, annotationAffinityCookieChangeOnFailure)
+	}
+
 	return cookie
 }
 
@@ -123,7 +128,7 @@ type affinity struct {
 
 // ParseAnnotations parses the annotations contained in the ingress
 // rule used to configure the affinity directives
-func (a affinity) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a affinity) Parse(ing *networking.Ingress) (interface{}, error) {
 	cookie := &Cookie{}
 	// Check the type of affinity that will be used
 	at, err := parser.GetStringAnnotation(annotationAffinityType, ing)

internal/ingress/annotations/sessionaffinity/main_test.go

@@ -20,35 +20,35 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	defaultBackend := extensions.IngressBackend{
+	defaultBackend := networking.IngressBackend{
 		ServiceName: "default-backend",
 		ServicePort: intstr.FromInt(80),
 	}
 
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "foo.bar.com",
-					IngressRuleValue: extensions.IngressRuleValue{
+					IngressRuleValue: networking.IngressRuleValue{
-						HTTP: &extensions.HTTPIngressRuleValue{
+						HTTP: &networking.HTTPIngressRuleValue{
-							Paths: []extensions.HTTPIngressPath{
+							Paths: []networking.HTTPIngressPath{
 								{
 									Path:    "/foo",
 									Backend: defaultBackend,
@@ -103,4 +103,8 @@ func TestIngressAffinityCookieConfig(t *testing.T) {
 	if !nginxAffinity.Cookie.ChangeOnFailure {
 		t.Errorf("expected change of failure parameter set to true but returned %v", nginxAffinity.Cookie.ChangeOnFailure)
 	}
+
+	if !nginxAffinity.Cookie.ChangeOnFailure {
+		t.Errorf("expected change of failure parameter set to true but returned %v", nginxAffinity.Cookie.ChangeOnFailure)
+	}
 }

internal/ingress/annotations/snippet/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package snippet
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -35,6 +35,6 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 // Parse parses the annotations contained in the ingress rule
 // used to indicate if the location/s contains a fragment of
 // configuration to be included inside the paths of the rules
-func (a snippet) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a snippet) Parse(ing *networking.Ingress) (interface{}, error) {
 	return parser.GetStringAnnotation("configuration-snippet", ing)
 }

internal/ingress/annotations/snippet/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -44,12 +44,12 @@ func TestParse(t *testing.T) {
 		{nil, ""},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	for _, testCase := range testCases {

internal/ingress/annotations/sslcipher/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package sslcipher
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -34,6 +34,6 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // Parse parses the annotations contained in the ingress rule
 // used to add ssl-ciphers to the server name
-func (sc sslCipher) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (sc sslCipher) Parse(ing *networking.Ingress) (interface{}, error) {
 	return parser.GetStringAnnotation("ssl-ciphers", ing)
 }

internal/ingress/annotations/sslcipher/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -45,12 +45,12 @@ func TestParse(t *testing.T) {
 		{nil, ""},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	for _, testCase := range testCases {

internal/ingress/annotations/sslpassthrough/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package sslpassthrough
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	ing_errors "k8s.io/ingress-nginx/internal/ingress/errors"
@@ -35,7 +35,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // ParseAnnotations parses the annotations contained in the ingress
 // rule used to indicate if is required to configure
-func (a sslpt) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a sslpt) Parse(ing *networking.Ingress) (interface{}, error) {
 	if ing.GetAnnotations() == nil {
 		return false, ing_errors.ErrMissingAnnotations
 	}

internal/ingress/annotations/sslpassthrough/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -28,14 +28,14 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 )
 
-func buildIngress() *extensions.Ingress {
+func buildIngress() *networking.Ingress {
-	return &extensions.Ingress{
+	return &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Backend: &extensions.IngressBackend{
+			Backend: &networking.IngressBackend{
 				ServiceName: "default-backend",
 				ServicePort: intstr.FromInt(80),
 			},
@@ -61,7 +61,7 @@ func TestParseAnnotations(t *testing.T) {
 	}
 
 	// test with a valid host
-	ing.Spec.TLS = []extensions.IngressTLS{
+	ing.Spec.TLS = []networking.IngressTLS{
 		{
 			Hosts: []string{"foo.bar.com"},
 		},

internal/ingress/annotations/upstreamhashby/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package upstreamhashby
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -40,7 +40,7 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 }
 
 // Parse parses the annotations contained in the ingress rule
-func (a upstreamhashby) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a upstreamhashby) Parse(ing *networking.Ingress) (interface{}, error) {
 	upstreamHashBy, _ := parser.GetStringAnnotation("upstream-hash-by", ing)
 	upstreamHashBySubset, _ := parser.GetBoolAnnotation("upstream-hash-by-subset", ing)
 	upstreamHashbySubsetSize, _ := parser.GetIntAnnotation("upstream-hash-by-subset-size", ing)

internal/ingress/annotations/upstreamhashby/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -44,12 +44,12 @@ func TestParse(t *testing.T) {
 		{nil, ""},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	for _, testCase := range testCases {

internal/ingress/annotations/upstreamvhost/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package upstreamvhost
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -35,6 +35,6 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 // Parse parses the annotations contained in the ingress rule
 // used to indicate if the location/s contains a fragment of
 // configuration to be included inside the paths of the rules
-func (a upstreamVhost) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (a upstreamVhost) Parse(ing *networking.Ingress) (interface{}, error) {
 	return parser.GetStringAnnotation("upstream-vhost", ing)
 }

internal/ingress/annotations/upstreamvhost/main_test.go

@@ -20,19 +20,19 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
 )
 
 func TestParse(t *testing.T) {
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	data := map[string]string{}

internal/ingress/annotations/xforwardedprefix/main.go

@@ -17,7 +17,7 @@ limitations under the License.
 package xforwardedprefix
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -34,6 +34,6 @@ func NewParser(r resolver.Resolver) parser.IngressAnnotation {
 
 // Parse parses the annotations contained in the ingress rule
 // used to add an x-forwarded-prefix header to the request
-func (cbbs xforwardedprefix) Parse(ing *extensions.Ingress) (interface{}, error) {
+func (cbbs xforwardedprefix) Parse(ing *networking.Ingress) (interface{}, error) {
 	return parser.GetStringAnnotation("x-forwarded-prefix", ing)
 }

internal/ingress/annotations/xforwardedprefix/main_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	api "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/parser"
 	"k8s.io/ingress-nginx/internal/ingress/resolver"
@@ -44,12 +44,12 @@ func TestParse(t *testing.T) {
 		{nil, ""},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: meta_v1.ObjectMeta{
 			Name:      "foo",
 			Namespace: api.NamespaceDefault,
 		},
-		Spec: extensions.IngressSpec{},
+		Spec: networking.IngressSpec{},
 	}
 
 	for _, testCase := range testCases {

internal/ingress/controller/controller.go

@@ -25,7 +25,7 @@ import (
 
 	"github.com/mitchellh/hashstructure"
 	apiv1 "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/apimachinery/pkg/util/wait"
@@ -200,7 +200,7 @@ func (n *NGINXController) syncIngress(interface{}) error {
 
 // CheckIngress returns an error in case the provided ingress, when added
 // to the current configuration, generates an invalid configuration
-func (n *NGINXController) CheckIngress(ing *extensions.Ingress) error {
+func (n *NGINXController) CheckIngress(ing *networking.Ingress) error {
 	//TODO: this is wrong
 	if n == nil {
 		return fmt.Errorf("cannot check ingress on a nil ingress controller")
@@ -808,7 +808,7 @@ func (n *NGINXController) createUpstreams(data []*ingress.Ingress, du *ingress.B
 
 // getServiceClusterEndpoint returns an Endpoint corresponding to the ClusterIP
 // field of a Service.
-func (n *NGINXController) getServiceClusterEndpoint(svcKey string, backend *extensions.IngressBackend) (endpoint ingress.Endpoint, err error) {
+func (n *NGINXController) getServiceClusterEndpoint(svcKey string, backend *networking.IngressBackend) (endpoint ingress.Endpoint, err error) {
 	svc, err := n.store.GetService(svcKey)
 	if err != nil {
 		return endpoint, fmt.Errorf("service %q does not exist", svcKey)

internal/ingress/controller/controller_test.go

@@ -32,7 +32,7 @@ import (
 	"github.com/eapache/channels"
 	corev1 "k8s.io/api/core/v1"
 	v1 "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/client-go/kubernetes/fake"
@@ -169,14 +169,14 @@ func TestCheckIngress(t *testing.T) {
 		ingresses: []*ingress.Ingress{},
 	}
 
-	ing := &extensions.Ingress{
+	ing := &networking.Ingress{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:        "test-ingress",
 			Namespace:   "user-namespace",
 			Annotations: map[string]string{},
 		},
-		Spec: extensions.IngressSpec{
+		Spec: networking.IngressSpec{
-			Rules: []extensions.IngressRule{
+			Rules: []networking.IngressRule{
 				{
 					Host: "example.com",
 				},
@@ -262,20 +262,20 @@ func TestMergeAlternativeBackends(t *testing.T) {
 	}{
 		"alternative backend has no server and embeds into matching real backend": {
 			&ingress.Ingress{
-				Ingress: extensions.Ingress{
+				Ingress: networking.Ingress{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "example",
 					},
-					Spec: extensions.IngressSpec{
+					Spec: networking.IngressSpec{
-						Rules: []extensions.IngressRule{
+						Rules: []networking.IngressRule{
 							{
 								Host: "example.com",
-								IngressRuleValue: extensions.IngressRuleValue{
+								IngressRuleValue: networking.IngressRuleValue{
-									HTTP: &extensions.HTTPIngressRuleValue{
+									HTTP: &networking.HTTPIngressRuleValue{
-										Paths: []extensions.HTTPIngressPath{
+										Paths: []networking.HTTPIngressPath{
 											{
 												Path: "/",
-												Backend: extensions.IngressBackend{
+												Backend: networking.IngressBackend{
 													ServiceName: "http-svc-canary",
 													ServicePort: intstr.IntOrString{
 														Type:   intstr.Int,
@@ -343,20 +343,20 @@ func TestMergeAlternativeBackends(t *testing.T) {
 		},
 		"alternative backend merges with the correct real backend when multiple are present": {
 			&ingress.Ingress{
-				Ingress: extensions.Ingress{
+				Ingress: networking.Ingress{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "example",
 					},
-					Spec: extensions.IngressSpec{
+					Spec: networking.IngressSpec{
-						Rules: []extensions.IngressRule{
+						Rules: []networking.IngressRule{
 							{
 								Host: "foo.bar",
-								IngressRuleValue: extensions.IngressRuleValue{
+								IngressRuleValue: networking.IngressRuleValue{
-									HTTP: &extensions.HTTPIngressRuleValue{
+									HTTP: &networking.HTTPIngressRuleValue{
-										Paths: []extensions.HTTPIngressPath{
+										Paths: []networking.HTTPIngressPath{
 											{
 												Path: "/",
-												Backend: extensions.IngressBackend{
+												Backend: networking.IngressBackend{
 													ServiceName: "foo-http-svc-canary",
 													ServicePort: intstr.IntOrString{
 														Type:   intstr.Int,
@@ -370,12 +370,12 @@ func TestMergeAlternativeBackends(t *testing.T) {
 							},
 							{
 								Host: "example.com",
-								IngressRuleValue: extensions.IngressRuleValue{
+								IngressRuleValue: networking.IngressRuleValue{
-									HTTP: &extensions.HTTPIngressRuleValue{
+									HTTP: &networking.HTTPIngressRuleValue{
-										Paths: []extensions.HTTPIngressPath{
+										Paths: []networking.HTTPIngressPath{
 											{
 												Path: "/",
-												Backend: extensions.IngressBackend{
+												Backend: networking.IngressBackend{
 													ServiceName: "http-svc-canary",
 													ServicePort: intstr.IntOrString{
 														Type:   intstr.Int,
@@ -476,20 +476,20 @@ func TestMergeAlternativeBackends(t *testing.T) {
 		},
 		"alternative backend does not merge into itself": {
 			&ingress.Ingress{
-				Ingress: extensions.Ingress{
+				Ingress: networking.Ingress{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "example",
 					},
-					Spec: extensions.IngressSpec{
+					Spec: networking.IngressSpec{
-						Rules: []extensions.IngressRule{
+						Rules: []networking.IngressRule{
 							{
 								Host: "example.com",
-								IngressRuleValue: extensions.IngressRuleValue{
+								IngressRuleValue: networking.IngressRuleValue{
-									HTTP: &extensions.HTTPIngressRuleValue{
+									HTTP: &networking.HTTPIngressRuleValue{
-										Paths: []extensions.HTTPIngressPath{
+										Paths: []networking.HTTPIngressPath{
 											{
 												Path: "/",
-												Backend: extensions.IngressBackend{
+												Backend: networking.IngressBackend{
 													ServiceName: "http-svc-canary",
 													ServicePort: intstr.IntOrString{
 														Type:   intstr.Int,
@@ -520,12 +520,12 @@ func TestMergeAlternativeBackends(t *testing.T) {
 		},
 		"catch-all alternative backend has no server and embeds into matching real backend": {
 			&ingress.Ingress{
-				Ingress: extensions.Ingress{
+				Ingress: networking.Ingress{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "example",
 					},
-					Spec: extensions.IngressSpec{
+					Spec: networking.IngressSpec{
-						Backend: &extensions.IngressBackend{
+						Backend: &networking.IngressBackend{
 							ServiceName: "http-svc-canary",
 							ServicePort: intstr.IntOrString{
 								IntVal: 80,
@@ -586,12 +586,12 @@ func TestMergeAlternativeBackends(t *testing.T) {
 		},
 		"catch-all alternative backend does not merge into itself": {
 			&ingress.Ingress{
-				Ingress: extensions.Ingress{
+				Ingress: networking.Ingress{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "example",
 					},
-					Spec: extensions.IngressSpec{
+					Spec: networking.IngressSpec{
-						Backend: &extensions.IngressBackend{
+						Backend: &networking.IngressBackend{
 							ServiceName: "http-svc-canary",
 							ServicePort: intstr.IntOrString{
 								IntVal: 80,
@@ -696,15 +696,15 @@ func TestExtractTLSSecretName(t *testing.T) {
 		"ingress tls, nil secret": {
 			"foo.bar",
 			&ingress.Ingress{
-				Ingress: extensions.Ingress{
+				Ingress: networking.Ingress{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "test",
 					},
-					Spec: extensions.IngressSpec{
+					Spec: networking.IngressSpec{
-						TLS: []extensions.IngressTLS{
+						TLS: []networking.IngressTLS{
 							{SecretName: "demo"},
 						},
-						Rules: []extensions.IngressRule{
+						Rules: []networking.IngressRule{
 							{
 								Host: "foo.bar",
 							},
@@ -720,15 +720,15 @@ func TestExtractTLSSecretName(t *testing.T) {
 		"ingress tls, no host, matching cert cn": {
 			"foo.bar",
 			&ingress.Ingress{
-				Ingress: extensions.Ingress{
+				Ingress: networking.Ingress{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "test",
 					},
-					Spec: extensions.IngressSpec{
+					Spec: networking.IngressSpec{
-						TLS: []extensions.IngressTLS{
+						TLS: []networking.IngressTLS{
 							{SecretName: "demo"},
 						},
-						Rules: []extensions.IngressRule{
+						Rules: []networking.IngressRule{
 							{
 								Host: "foo.bar",
 							},
@@ -746,17 +746,17 @@ func TestExtractTLSSecretName(t *testing.T) {
 		"ingress tls, no host, wildcard cert with matching cn": {
 			"foo.bar",
 			&ingress.Ingress{
-				Ingress: extensions.Ingress{
+				Ingress: networking.Ingress{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "test",
 					},
-					Spec: extensions.IngressSpec{
+					Spec: networking.IngressSpec{
-						TLS: []extensions.IngressTLS{
+						TLS: []networking.IngressTLS{
 							{
 								SecretName: "demo",
 							},
 						},
-						Rules: []extensions.IngressRule{
+						Rules: []networking.IngressRule{
 							{
 								Host: "test.foo.bar",
 							},
@@ -774,18 +774,18 @@ func TestExtractTLSSecretName(t *testing.T) {
 		"ingress tls, hosts, matching cert cn": {
 			"foo.bar",
 			&ingress.Ingress{
-				Ingress: extensions.Ingress{
+				Ingress: networking.Ingress{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "test",
 					},
-					Spec: extensions.IngressSpec{
+					Spec: networking.IngressSpec{
-						TLS: []extensions.IngressTLS{
+						TLS: []networking.IngressTLS{
 							{
 								Hosts:      []string{"foo.bar", "example.com"},
 								SecretName: "demo",
 							},
 						},
-						Rules: []extensions.IngressRule{
+						Rules: []networking.IngressRule{
 							{
 								Host: "foo.bar",
 							},
@@ -820,12 +820,12 @@ func TestGetBackendServers(t *testing.T) {
 		{
 			Ingresses: []*ingress.Ingress{
 				{
-					Ingress: extensions.Ingress{
+					Ingress: networking.Ingress{
 						ObjectMeta: metav1.ObjectMeta{
 							Namespace: "example",
 						},
-						Spec: extensions.IngressSpec{
+						Spec: networking.IngressSpec{
-							Backend: &extensions.IngressBackend{
+							Backend: &networking.IngressBackend{
 								ServiceName: "http-svc-canary",
 								ServicePort: intstr.IntOrString{
 									IntVal: 80,
@@ -862,12 +862,12 @@ func TestGetBackendServers(t *testing.T) {
 		{
 			Ingresses: []*ingress.Ingress{
 				{
-					Ingress: extensions.Ingress{
+					Ingress: networking.Ingress{
 						ObjectMeta: metav1.ObjectMeta{
 							Namespace: "example",
 						},
-						Spec: extensions.IngressSpec{
+						Spec: networking.IngressSpec{
-							Backend: &extensions.IngressBackend{
+							Backend: &networking.IngressBackend{
 								ServiceName: "http-svc-canary",
 								ServicePort: intstr.IntOrString{
 									IntVal: 80,
@@ -882,12 +882,12 @@ func TestGetBackendServers(t *testing.T) {
 					},
 				},
 				{
-					Ingress: extensions.Ingress{
+					Ingress: networking.Ingress{
 						ObjectMeta: metav1.ObjectMeta{
 							Namespace: "example",
 						},
-						Spec: extensions.IngressSpec{
+						Spec: networking.IngressSpec{
-							Backend: &extensions.IngressBackend{
+							Backend: &networking.IngressBackend{
 								ServiceName: "http-svc",
 								ServicePort: intstr.IntOrString{
 									IntVal: 80,
@@ -924,20 +924,20 @@ func TestGetBackendServers(t *testing.T) {
 		{
 			Ingresses: []*ingress.Ingress{
 				{
-					Ingress: extensions.Ingress{
+					Ingress: networking.Ingress{
 						ObjectMeta: metav1.ObjectMeta{
 							Namespace: "example",
 						},
-						Spec: extensions.IngressSpec{
+						Spec: networking.IngressSpec{
-							Rules: []extensions.IngressRule{
+							Rules: []networking.IngressRule{
 								{
 									Host: "example.com",
-									IngressRuleValue: extensions.IngressRuleValue{
+									IngressRuleValue: networking.IngressRuleValue{
-										HTTP: &extensions.HTTPIngressRuleValue{
+										HTTP: &networking.HTTPIngressRuleValue{
-											Paths: []extensions.HTTPIngressPath{
+											Paths: []networking.HTTPIngressPath{
 												{
 													Path: "/",
-													Backend: extensions.IngressBackend{
+													Backend: networking.IngressBackend{
 														ServiceName: "http-svc-canary",
 														ServicePort: intstr.IntOrString{
 															Type:   intstr.Int,
@@ -981,21 +981,21 @@ func TestGetBackendServers(t *testing.T) {
 		{
 			Ingresses: []*ingress.Ingress{
 				{
-					Ingress: extensions.Ingress{
+					Ingress: networking.Ingress{
 						ObjectMeta: metav1.ObjectMeta{
 							Name:      "example",
 							Namespace: "example",
 						},
-						Spec: extensions.IngressSpec{
+						Spec: networking.IngressSpec{
-							Rules: []extensions.IngressRule{
+							Rules: []networking.IngressRule{
 								{
 									Host: "example.com",
-									IngressRuleValue: extensions.IngressRuleValue{
+									IngressRuleValue: networking.IngressRuleValue{
-										HTTP: &extensions.HTTPIngressRuleValue{
+										HTTP: &networking.HTTPIngressRuleValue{
-											Paths: []extensions.HTTPIngressPath{
+											Paths: []networking.HTTPIngressPath{
 												{
 													Path: "/",
-													Backend: extensions.IngressBackend{
+													Backend: networking.IngressBackend{
 														ServiceName: "http-svc",
 														ServicePort: intstr.IntOrString{
 															Type:   intstr.Int,
@@ -1017,21 +1017,21 @@ func TestGetBackendServers(t *testing.T) {
 					},
 				},
 				{
-					Ingress: extensions.Ingress{
+					Ingress: networking.Ingress{
 						ObjectMeta: metav1.ObjectMeta{
 							Name:      "example-canary",
 							Namespace: "example",
 						},
-						Spec: extensions.IngressSpec{
+						Spec: networking.IngressSpec{
-							Rules: []extensions.IngressRule{
+							Rules: []networking.IngressRule{
 								{
 									Host: "example.com",
-									IngressRuleValue: extensions.IngressRuleValue{
+									IngressRuleValue: networking.IngressRuleValue{
-										HTTP: &extensions.HTTPIngressRuleValue{
+										HTTP: &networking.HTTPIngressRuleValue{
-											Paths: []extensions.HTTPIngressPath{
+											Paths: []networking.HTTPIngressPath{
 												{
 													Path: "/",
-													Backend: extensions.IngressBackend{
+													Backend: networking.IngressBackend{
 														ServiceName: "http-svc-canary",
 														ServicePort: intstr.IntOrString{
 															Type:   intstr.Int,

internal/ingress/controller/store/backend_ssl.go

@@ -24,7 +24,7 @@ import (
 	"k8s.io/klog"
 
 	apiv1 "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"k8s.io/ingress-nginx/internal/file"
@@ -208,7 +208,7 @@ func (s *k8sStore) checkSSLChainIssues() {
 func (s *k8sStore) sendDummyEvent() {
 	s.updateCh.In() <- Event{
 		Type: UpdateEvent,
-		Obj: &extensions.Ingress{
+		Obj: &networking.Ingress{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "dummy",
 				Namespace: "dummy",

internal/ingress/controller/store/ingress.go

@@ -17,7 +17,7 @@ limitations under the License.
 package store
 
 import (
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	"k8s.io/client-go/tools/cache"
 )
 
@@ -27,7 +27,7 @@ type IngressLister struct {
 }
 
 // ByKey returns the Ingress matching key in the local Ingress Store.
-func (il IngressLister) ByKey(key string) (*extensions.Ingress, error) {
+func (il IngressLister) ByKey(key string) (*networking.Ingress, error) {
 	i, exists, err := il.GetByKey(key)
 	if err != nil {
 		return nil, err
@@ -35,5 +35,5 @@ func (il IngressLister) ByKey(key string) (*extensions.Ingress, error) {
 	if !exists {
 		return nil, NotExistsError(key)
 	}
-	return i.(*extensions.Ingress), nil
+	return i.(*networking.Ingress), nil
 }

internal/ingress/controller/store/store.go

@@ -25,10 +25,12 @@ import (
 	"sync"
 	"time"
 
-	"github.com/eapache/channels"
+	"k8s.io/klog"
 
+	"github.com/eapache/channels"
 	corev1 "k8s.io/api/core/v1"
-	extensions "k8s.io/api/extensions/v1beta1"
+	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
+	networkingv1beta1 "k8s.io/api/networking/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 	k8sruntime "k8s.io/apimachinery/pkg/runtime"
@@ -41,7 +43,6 @@ import (
 	clientcorev1 "k8s.io/client-go/kubernetes/typed/core/v1"
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/client-go/tools/record"
-	"k8s.io/klog"
 
 	"k8s.io/ingress-nginx/internal/file"
 	"k8s.io/ingress-nginx/internal/ingress"
@@ -274,7 +275,12 @@ func New(checkOCSP bool,
 		informers.WithNamespace(namespace),
 		informers.WithTweakListOptions(func(*metav1.ListOptions) {}))
 
+	if k8s.IsNetworkingIngressAvailable {
+		store.informers.Ingress = infFactory.Networking().V1beta1().Ingresses().Informer()
+	} else {
 		store.informers.Ingress = infFactory.Extensions().V1beta1().Ingresses().Informer()
+	}
+
 	store.listers.Ingress.Store = store.informers.Ingress.GetStore()
 
 	store.informers.Endpoint = infFactory.Core().V1().Endpoints().Informer()
@@ -308,7 +314,7 @@ func New(checkOCSP bool,
 	store.listers.Pod.Store = store.informers.Pod.GetStore()
 
 	ingDeleteHandler := func(obj interface{}) {
-		ing, ok := obj.(*extensions.Ingress)
+		ing, ok := toIngress(obj)
 		if !ok {
 			// If we reached here it means the ingress was deleted but its final state is unrecorded.
 			tombstone, ok := obj.(cache.DeletedFinalStateUnknown)
@@ -316,12 +322,13 @@ func New(checkOCSP bool,
 				klog.Errorf("couldn't get object from tombstone %#v", obj)
 				return
 			}
-			ing, ok = tombstone.Obj.(*extensions.Ingress)
+			ing, ok = tombstone.Obj.(*networkingv1beta1.Ingress)
 			if !ok {
 				klog.Errorf("Tombstone contained object that is not an Ingress: %#v", obj)
 				return
 			}
 		}
+
 		if !class.IsValid(ing) {
 			klog.Infof("ignoring delete for ingress %v based on annotation %v", ing.Name, class.IngressKey)
 			return
@@ -345,7 +352,7 @@ func New(checkOCSP bool,
 
 	ingEventHandler := cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
-			ing := obj.(*extensions.Ingress)
+			ing, _ := toIngress(obj)
 			if !class.IsValid(ing) {
 				a, _ := parser.GetStringAnnotation(class.IngressKey, ing)
 				klog.Infof("ignoring add for ingress %v based on annotation %v with value %v", ing.Name, class.IngressKey, a)
@@ -368,8 +375,9 @@ func New(checkOCSP bool,
 		},
 		DeleteFunc: ingDeleteHandler,
 		UpdateFunc: func(old, cur interface{}) {
-			oldIng := old.(*extensions.Ingress)
+			oldIng, _ := toIngress(old)
-			curIng := cur.(*extensions.Ingress)
+			curIng, _ := toIngress(cur)
+
 			validOld := class.IsValid(oldIng)
 			validCur := class.IsValid(curIng)
 			if !validOld && validCur {
@@ -622,17 +630,17 @@ func New(checkOCSP bool,
 
 // isCatchAllIngress returns whether or not an ingress produces a
 // catch-all server, and so should be ignored when --disable-catch-all is set
-func isCatchAllIngress(spec extensions.IngressSpec) bool {
+func isCatchAllIngress(spec networkingv1beta1.IngressSpec) bool {
 	return spec.Backend != nil && len(spec.Rules) == 0
 }
 
 // syncIngress parses ingress annotations converting the value of the
 // annotation to a go struct
-func (s *k8sStore) syncIngress(ing *extensions.Ingress) {
+func (s *k8sStore) syncIngress(ing *networkingv1beta1.Ingress) {
 	key := k8s.MetaNamespaceKey(ing)
 	klog.V(3).Infof("updating annotations information for ingress %v", key)
 
-	copyIng := &extensions.Ingress{}
+	copyIng := &networkingv1beta1.Ingress{}
 	ing.ObjectMeta.DeepCopyInto(&copyIng.ObjectMeta)
 	ing.Spec.DeepCopyInto(&copyIng.Spec)
 	ing.Status.DeepCopyInto(&copyIng.Status)
@@ -660,7 +668,7 @@ func (s *k8sStore) syncIngress(ing *extensions.Ingress) {
 
 // updateSecretIngressMap takes an Ingress and updates all Secret objects it
 // references in secretIngressMap.
-func (s *k8sStore) updateSecretIngressMap(ing *extensions.Ingress) {
+func (s *k8sStore) updateSecretIngressMap(ing *networkingv1beta1.Ingress) {
 	key := k8s.MetaNamespaceKey(ing)
 	klog.V(3).Infof("updating references to secrets for ingress %v", key)
 
@@ -702,7 +710,7 @@ func (s *k8sStore) updateSecretIngressMap(ing *extensions.Ingress) {
 
 // objectRefAnnotationNsKey returns an object reference formatted as a
 // 'namespace/name' key from the given annotation name.
-func objectRefAnnotationNsKey(ann string, ing *extensions.Ingress) (string, error) {
+func objectRefAnnotationNsKey(ann string, ing *networkingv1beta1.Ingress) (string, error) {
 	annValue, err := parser.GetStringAnnotation(ann, ing)
 	if err != nil {
 		return "", err
@@ -721,7 +729,7 @@ func objectRefAnnotationNsKey(ann string, ing *extensions.Ingress) (string, erro
 
 // syncSecrets synchronizes data from all Secrets referenced by the given
 // Ingress with the local store and file system.
-func (s *k8sStore) syncSecrets(ing *extensions.Ingress) {
+func (s *k8sStore) syncSecrets(ing *networkingv1beta1.Ingress) {
 	key := k8s.MetaNamespaceKey(ing)
 	for _, secrKey := range s.secretIngressMap.ReferencedBy(key) {
 		s.syncSecret(secrKey)
@@ -751,7 +759,7 @@ func (s *k8sStore) GetService(key string) (*corev1.Service, error) {
 }
 
 // getIngress returns the Ingress matching key.
-func (s *k8sStore) getIngress(key string) (*extensions.Ingress, error) {
+func (s *k8sStore) getIngress(key string) (*networkingv1beta1.Ingress, error) {
 	ing, err := s.listers.IngressWithAnnotation.ByKey(key)
 	if err != nil {
 		return nil, err
@@ -892,3 +900,40 @@ func (s k8sStore) GetRunningControllerPodsCount() int {
 
 	return count
 }
+
+var runtimeScheme = k8sruntime.NewScheme()
+
+func init() {
+	extensionsv1beta1.AddToScheme(runtimeScheme)
+	networkingv1beta1.AddToScheme(runtimeScheme)
+}
+
+func fromExtensions(old *extensionsv1beta1.Ingress) (*networkingv1beta1.Ingress, error) {
+	networkingIngress := &networkingv1beta1.Ingress{}
+
+	err := runtimeScheme.Convert(old, networkingIngress, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return networkingIngress, nil
+}
+
+func toIngress(obj interface{}) (*networkingv1beta1.Ingress, bool) {
+	oldVersion, inExtension := obj.(*extensionsv1beta1.Ingress)
+	if inExtension {
+		ing, err := fromExtensions(oldVersion)
+		if err != nil {
+			klog.Errorf("unexpected error converting Ingress from extensions package: %v", err)
+			return nil, false
+		}
+
+		return ing, true
+	}
+
+	if ing, ok := obj.(*networkingv1beta1.Ingress); ok {
+		return ing, true
+	}
+
+	return nil, false
+}

internal/ingress/controller/store/store_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package store
 
 import (
+	"bytes"
 	"encoding/base64"
 	"fmt"
 	"io/ioutil"
@@ -29,6 +30,7 @@ import (
 	"github.com/eapache/channels"
 	v1 "k8s.io/api/core/v1"
 	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	k8sErrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
@@ -44,6 +46,8 @@ import (
 )
 
 func TestStore(t *testing.T) {
+	k8s.IsNetworkingIngressAvailable = true
+
 	pod := &k8s.PodInfo{
 		Name:      "testpod",
 		Namespace: v1.NamespaceDefault,
@@ -61,8 +65,7 @@ func TestStore(t *testing.T) {
 		t.Fatalf("error: %v", err)
 	}
 
-	// TODO: this defer is called after any error (even the expected ones)
+	defer te.Stop()
-	// defer te.Stop()
 
 	clientSet, err := kubernetes.NewForConfig(cfg)
 	if err != nil {
@@ -149,7 +152,7 @@ func TestStore(t *testing.T) {
 				if e.Obj == nil {
 					continue
 				}
-				if _, ok := e.Obj.(*extensions.Ingress); !ok {
+				if _, ok := e.Obj.(*networking.Ingress); !ok {
 					continue
 				}
 
@@ -181,22 +184,21 @@ func TestStore(t *testing.T) {
 
 		storer.Run(stopCh)
 
-		ing := ensureIngress(&extensions.Ingress{
+		ing := ensureIngress(&networking.Ingress{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "dummy",
 				Namespace: ns,
-				SelfLink:  fmt.Sprintf("/apis/extensions/v1beta1/namespaces/%s/ingresses/dummy", ns),
 			},
-			Spec: extensions.IngressSpec{
+			Spec: networking.IngressSpec{
-				Rules: []extensions.IngressRule{
+				Rules: []networking.IngressRule{
 					{
 						Host: "dummy",
-						IngressRuleValue: extensions.IngressRuleValue{
+						IngressRuleValue: networking.IngressRuleValue{
-							HTTP: &extensions.HTTPIngressRuleValue{
+							HTTP: &networking.HTTPIngressRuleValue{
-								Paths: []extensions.HTTPIngressPath{
+								Paths: []networking.HTTPIngressPath{
 									{
 										Path: "/",
-										Backend: extensions.IngressBackend{
+										Backend: networking.IngressBackend{
 											ServiceName: "http-svc",
 											ServicePort: intstr.FromInt(80),
 										},
@@ -216,25 +218,24 @@ func TestStore(t *testing.T) {
 		time.Sleep(1 * time.Second)
 
 		// create an invalid ingress (different class)
-		invalidIngress := ensureIngress(&extensions.Ingress{
+		invalidIngress := ensureIngress(&networking.Ingress{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "custom-class",
-				SelfLink:  fmt.Sprintf("/apis/extensions/v1beta1/namespaces/%s/ingresses/custom-class", ns),
 				Namespace: ns,
 				Annotations: map[string]string{
 					"kubernetes.io/ingress.class": "something",
 				},
 			},
-			Spec: extensions.IngressSpec{
+			Spec: networking.IngressSpec{
-				Rules: []extensions.IngressRule{
+				Rules: []networking.IngressRule{
 					{
 						Host: "dummy",
-						IngressRuleValue: extensions.IngressRuleValue{
+						IngressRuleValue: networking.IngressRuleValue{
-							HTTP: &extensions.HTTPIngressRuleValue{
+							HTTP: &networking.HTTPIngressRuleValue{
-								Paths: []extensions.HTTPIngressPath{
+								Paths: []networking.HTTPIngressPath{
 									{
 										Path: "/",
-										Backend: extensions.IngressBackend{
+										Backend: networking.IngressBackend{
 											ServiceName: "http-svc",
 											ServicePort: intstr.FromInt(80),
 										},
@@ -257,7 +258,7 @@ func TestStore(t *testing.T) {
 		// Secret takes a bit to update
 		time.Sleep(3 * time.Second)
 
-		err = clientSet.ExtensionsV1beta1().Ingresses(ni.Namespace).Delete(ni.Name, &metav1.DeleteOptions{})
+		err = clientSet.NetworkingV1beta1().Ingresses(ni.Namespace).Delete(ni.Name, &metav1.DeleteOptions{})
 		if err != nil {
 			t.Errorf("error creating ingress: %v", err)
 		}
@@ -302,7 +303,7 @@ func TestStore(t *testing.T) {
 				if e.Obj == nil {
 					continue
 				}
-				if _, ok := e.Obj.(*extensions.Ingress); !ok {
+				if _, ok := e.Obj.(*networking.Ingress); !ok {
 					continue
 				}
 
@@ -335,25 +336,24 @@ func TestStore(t *testing.T) {
 		storer.Run(stopCh)
 
 		// create an invalid ingress (different class)
-		invalidIngress := ensureIngress(&extensions.Ingress{
+		invalidIngress := ensureIngress(&networking.Ingress{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "custom-class",
-				SelfLink:  fmt.Sprintf("/apis/extensions/v1beta1/namespaces/%s/ingresses/custom-class", ns),
 				Namespace: ns,
 				Annotations: map[string]string{
 					"kubernetes.io/ingress.class": "something",
 				},
 			},
-			Spec: extensions.IngressSpec{
+			Spec: networking.IngressSpec{
-				Rules: []extensions.IngressRule{
+				Rules: []networking.IngressRule{
 					{
 						Host: "dummy",
-						IngressRuleValue: extensions.IngressRuleValue{
+						IngressRuleValue: networking.IngressRuleValue{
-							HTTP: &extensions.HTTPIngressRuleValue{
+							HTTP: &networking.HTTPIngressRuleValue{
-								Paths: []extensions.HTTPIngressPath{
+								Paths: []networking.HTTPIngressPath{
 									{
 										Path: "/",
-										Backend: extensions.IngressBackend{
+										Backend: networking.IngressBackend{
 											ServiceName: "http-svc",
 											ServicePort: intstr.FromInt(80),
 										},
@@ -535,19 +535,18 @@ func TestStore(t *testing.T) {
 		ingressName := "ingress-with-secret"
 		secretName := "referenced"
 
-		ing := ensureIngress(&extensions.Ingress{
+		ing := ensureIngress(&networking.Ingress{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      ingressName,
 				Namespace: ns,
-				SelfLink:  fmt.Sprintf("/apis/extensions/v1beta1/namespaces/%s/ingresses/%s", ns, ingressName),
 			},
-			Spec: extensions.IngressSpec{
+			Spec: networking.IngressSpec{
-				TLS: []extensions.IngressTLS{
+				TLS: []networking.IngressTLS{
 					{
 						SecretName: secretName,
 					},
 				},
-				Backend: &extensions.IngressBackend{
+				Backend: &networking.IngressBackend{
 					ServiceName: "http-svc",
 					ServicePort: intstr.FromInt(80),
 				},
@@ -648,28 +647,27 @@ func TestStore(t *testing.T) {
 		name := "ingress-with-secret"
 		secretHosts := []string{name}
 
-		ing := ensureIngress(&extensions.Ingress{
+		ing := ensureIngress(&networking.Ingress{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      name,
 				Namespace: ns,
-				SelfLink:  fmt.Sprintf("/apis/extensions/v1beta1/namespaces/%s/ingresses/%s", ns, name),
 			},
-			Spec: extensions.IngressSpec{
+			Spec: networking.IngressSpec{
-				TLS: []extensions.IngressTLS{
+				TLS: []networking.IngressTLS{
 					{
 						Hosts:      secretHosts,
 						SecretName: name,
 					},
 				},
-				Rules: []extensions.IngressRule{
+				Rules: []networking.IngressRule{
 					{
 						Host: name,
-						IngressRuleValue: extensions.IngressRuleValue{
+						IngressRuleValue: networking.IngressRuleValue{
-							HTTP: &extensions.HTTPIngressRuleValue{
+							HTTP: &networking.HTTPIngressRuleValue{
-								Paths: []extensions.HTTPIngressPath{
+								Paths: []networking.HTTPIngressPath{
 									{
 										Path: "/",
-										Backend: extensions.IngressBackend{
+										Backend: networking.IngressBackend{
 											ServiceName: "http-svc",
 											ServicePort: intstr.FromInt(80),
 										},
@@ -780,7 +778,6 @@ func createConfigMap(clientSet kubernetes.Interface, ns string, t *testing.T) st
 	configMap := &v1.ConfigMap{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: "config",
-			SelfLink: fmt.Sprintf("/api/v1/namespaces/%s/configmaps/config", ns),
 		},
 	}
 
@@ -792,15 +789,15 @@ func createConfigMap(clientSet kubernetes.Interface, ns string, t *testing.T) st
 	return cm.Name
 }
 
-func ensureIngress(ingress *extensions.Ingress, clientSet kubernetes.Interface, t *testing.T) *extensions.Ingress {
+func ensureIngress(ingress *networking.Ingress, clientSet kubernetes.Interface, t *testing.T) *networking.Ingress {
 	t.Helper()
-	ing, err := clientSet.ExtensionsV1beta1().Ingresses(ingress.Namespace).Update(ingress)
+	ing, err := clientSet.NetworkingV1beta1().Ingresses(ingress.Namespace).Update(ingress)
 
 	if err != nil {
 		if k8sErrors.IsNotFound(err) {
 			t.Logf("Ingress %v not found, creating", ingress)
 
-			ing, err = clientSet.ExtensionsV1beta1().Ingresses(ingress.Namespace).Create(ingress)
+			ing, err = clientSet.NetworkingV1beta1().Ingresses(ingress.Namespace).Create(ingress)
 			if err != nil {
 				t.Fatalf("error creating ingress %+v: %v", ingress, err)
 			}
@@ -815,9 +812,9 @@ func ensureIngress(ingress *extensions.Ingress, clientSet kubernetes.Interface,
 	return ing
 }
 
-func deleteIngress(ingress *extensions.Ingress, clientSet kubernetes.Interface, t *testing.T) {
+func deleteIngress(ingress *networking.Ingress, clientSet kubernetes.Interface, t *testing.T) {
 	t.Helper()
-	err := clientSet.ExtensionsV1beta1().Ingresses(ingress.Namespace).Delete(ingress.Name, &metav1.DeleteOptions{})
+	err := clientSet.NetworkingV1beta1().Ingresses(ingress.Namespace).Delete(ingress.Name, &metav1.DeleteOptions{})
 
 	if err != nil {
 		t.Errorf("failed to delete ingress %+v: %v", ingress, err)
@@ -870,7 +867,7 @@ func newStore(t *testing.T) *k8sStore {
 func TestUpdateSecretIngressMap(t *testing.T) {
 	s := newStore(t)
 
-	ingTpl := &extensions.Ingress{
+	ingTpl := &networking.Ingress{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "test",
 			Namespace: "testns",
@@ -880,8 +877,8 @@ func TestUpdateSecretIngressMap(t *testing.T) {
 
 	t.Run("with TLS secret", func(t *testing.T) {
 		ing := ingTpl.DeepCopy()
-		ing.Spec = extensions.IngressSpec{
+		ing.Spec = networking.IngressSpec{
-			TLS: []extensions.IngressTLS{{SecretName: "tls"}},
+			TLS: []networking.IngressTLS{{SecretName: "tls"}},
 		}
 		s.listers.Ingress.Update(ing)
 		s.updateSecretIngressMap(ing)
@@ -935,7 +932,7 @@ func TestListIngresses(t *testing.T) {
 	s := newStore(t)
 
 	ingressToIgnore := &ingress.Ingress{
-		Ingress: extensions.Ingress{
+		Ingress: networking.Ingress{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "test-2",
 				Namespace: "testns",
@@ -944,8 +941,8 @@ func TestListIngresses(t *testing.T) {
 				},
 				CreationTimestamp: metav1.NewTime(time.Now()),
 			},
-			Spec: extensions.IngressSpec{
+			Spec: networking.IngressSpec{
-				Backend: &extensions.IngressBackend{
+				Backend: &networking.IngressBackend{
 					ServiceName: "demo",
 					ServicePort: intstr.FromInt(80),
 				},
@@ -955,21 +952,21 @@ func TestListIngresses(t *testing.T) {
 	s.listers.IngressWithAnnotation.Add(ingressToIgnore)
 
 	ingressWithoutPath := &ingress.Ingress{
-		Ingress: extensions.Ingress{
+		Ingress: networking.Ingress{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:              "test-3",
 				Namespace:         "testns",
 				CreationTimestamp: metav1.NewTime(time.Now()),
 			},
-			Spec: extensions.IngressSpec{
+			Spec: networking.IngressSpec{
-				Rules: []extensions.IngressRule{
+				Rules: []networking.IngressRule{
 					{
 						Host: "foo.bar",
-						IngressRuleValue: extensions.IngressRuleValue{
+						IngressRuleValue: networking.IngressRuleValue{
-							HTTP: &extensions.HTTPIngressRuleValue{
+							HTTP: &networking.HTTPIngressRuleValue{
-								Paths: []extensions.HTTPIngressPath{
+								Paths: []networking.HTTPIngressPath{
 									{
-										Backend: extensions.IngressBackend{
+										Backend: networking.IngressBackend{
 											ServiceName: "demo",
 											ServicePort: intstr.FromInt(80),
 										},
@@ -985,7 +982,7 @@ func TestListIngresses(t *testing.T) {
 	s.listers.IngressWithAnnotation.Add(ingressWithoutPath)
 
 	ingressWithNginxClass := &ingress.Ingress{
-		Ingress: extensions.Ingress{
+		Ingress: networking.Ingress{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "test-4",
 				Namespace: "testns",
@@ -994,16 +991,16 @@ func TestListIngresses(t *testing.T) {
 				},
 				CreationTimestamp: metav1.NewTime(time.Now()),
 			},
-			Spec: extensions.IngressSpec{
+			Spec: networking.IngressSpec{
-				Rules: []extensions.IngressRule{
+				Rules: []networking.IngressRule{
 					{
 						Host: "foo.bar",
-						IngressRuleValue: extensions.IngressRuleValue{
+						IngressRuleValue: networking.IngressRuleValue{
-							HTTP: &extensions.HTTPIngressRuleValue{
+							HTTP: &networking.HTTPIngressRuleValue{
-								Paths: []extensions.HTTPIngressPath{
+								Paths: []networking.HTTPIngressPath{
 									{
 										Path: "/demo",
-										Backend: extensions.IngressBackend{
+										Backend: networking.IngressBackend{
 											ServiceName: "demo",
 											ServicePort: intstr.FromInt(80),
 										},
@@ -1133,3 +1130,51 @@ func TestGetRunningControllerPodsCount(t *testing.T) {
 		t.Errorf("Expected 1 controller Pods but got %v", s)
 	}
 }
+
+func TestIngressConversion(t *testing.T) {
+	ing := &extensions.Ingress{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:              "old-ingress",
+			Namespace:         "demo",
+			CreationTimestamp: metav1.NewTime(time.Now()),
+		},
+		Spec: extensions.IngressSpec{
+			Rules: []extensions.IngressRule{
+				{
+					Host: "foo.bar",
+					IngressRuleValue: extensions.IngressRuleValue{
+						HTTP: &extensions.HTTPIngressRuleValue{
+							Paths: []extensions.HTTPIngressPath{
+								{
+									Backend: extensions.IngressBackend{
+										ServiceName: "demo",
+										ServicePort: intstr.FromInt(80),
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	new, err := fromExtensions(ing)
+	if err != nil {
+		t.Fatalf("unexpected error converting ingress: %v", err)
+	}
+
+	m1, err := new.Marshal()
+	if err != nil {
+		t.Fatalf("unexpected error marshalling Ingress: %v", err)
+	}
+
+	m2, err := ing.Marshal()
+	if err != nil {
+		t.Fatalf("unexpected error marshalling Ingress: %v", err)
+	}
+
+	if bytes.Compare(m1, m2) != 0 {
+		t.Fatalf("Expected marshalling of types should be equal")
+	}
+}

internal/ingress/controller/template/template_test.go

@@ -29,7 +29,7 @@ import (
 	"fmt"
 
 	jsoniter "github.com/json-iterator/go"
-	extensions "k8s.io/api/extensions/v1beta1"
+	networking "k8s.io/api/networking/v1beta1"
 	"k8s.io/ingress-nginx/internal/file"
 	"k8s.io/ingress-nginx/internal/ingress"
 	"k8s.io/ingress-nginx/internal/ingress/annotations/authreq"
@@ -909,7 +909,7 @@ func TestGetIngressInformation(t *testing.T) {
 	validIngress.Annotations = map[string]string{
 		"ingress.annotation": "ok",
 	}
-	validIngress.Spec.Backend = &extensions.IngressBackend{
+	validIngress.Spec.Backend = &networking.IngressBackend{
 		ServiceName: "a-svc",
 	}
 
@@ -927,15 +927,15 @@ func TestGetIngressInformation(t *testing.T) {
 	}
 
 	validIngress.Spec.Backend = nil
-	validIngress.Spec.Rules = []extensions.IngressRule{
+	validIngress.Spec.Rules = []networking.IngressRule{
 		{
 			Host: host,
-			IngressRuleValue: extensions.IngressRuleValue{
+			IngressRuleValue: networking.IngressRuleValue{
-				HTTP: &extensions.HTTPIngressRuleValue{
+				HTTP: &networking.HTTPIngressRuleValue{
-					Paths: []extensions.HTTPIngressPath{
+					Paths: []networking.HTTPIngressPath{
 						{
 							Path: "/ok",
-							Backend: extensions.IngressBackend{
+							Backend: networking.IngressBackend{
 								ServiceName: "b-svc",
 							},
 						},
@@ -959,14 +959,14 @@ func TestGetIngressInformation(t *testing.T) {
 		t.Errorf("Expected %v, but got %v", expected, info)
 	}
 
-	validIngress.Spec.Rules = append(validIngress.Spec.Rules, extensions.IngressRule{
+	validIngress.Spec.Rules = append(validIngress.Spec.Rules, networking.IngressRule{
 		Host: "host2",
-		IngressRuleValue: extensions.IngressRuleValue{
+		IngressRuleValue: networking.IngressRuleValue{
-			HTTP: &extensions.HTTPIngressRuleValue{
+			HTTP: &networking.HTTPIngressRuleValue{
-				Paths: []extensions.HTTPIngressPath{
+				Paths: []networking.HTTPIngressPath{
 					{
 						Path: "/ok",
-						Backend: extensions.IngressBackend{
+						Backend: networking.IngressBackend{
 							ServiceName: "c-svc",
 						},
 					},