Repository: Kong/kubernetes-ingress-controller
Pull request #4917 (2023-10-20 09:35:03)

tests(envtest): use comming log encoder in envtest suite when printing logs
**What this PR does / why we need it**:

Use the same log encoder for manager logs in `envtest` suite as when running the manager.



Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 10fa1e343..700c84f22 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -149,6 +149,9 @@ Adding a new version? You'll need three changes:
 
 - Update paths of Konnect APIs from `runtime_groups/*` to `control-planes/*`.
 [#4566](https://github.com/Kong/kubernetes-ingress-controller/pull/4566)
+- Bump version of gateway API to `1.0.0-rc1` and support `Gateway`, `GatewayClass`
+  and `HTTPRoute` in API version `gateway.networking.k8s.io/v1`.
+[#4893](https://github.com/Kong/kubernetes-ingress-controller/pull/4893)
 
 ### Added
 
diff --git a/go.mod b/go.mod
index 64983248d..a2c23895a 100644
--- a/go.mod
+++ b/go.mod
@@ -54,9 +54,9 @@ require (
 	k8s.io/apiextensions-apiserver v0.28.2
 	k8s.io/apimachinery v0.28.3
 	k8s.io/client-go v0.28.3
-	k8s.io/component-base v0.28.2
+	k8s.io/component-base v0.28.3
 	sigs.k8s.io/controller-runtime v0.16.2
-	sigs.k8s.io/gateway-api v0.8.1
+	sigs.k8s.io/gateway-api v1.0.0-rc1
 	sigs.k8s.io/kustomize/api v0.14.0
 	sigs.k8s.io/kustomize/kyaml v0.14.3
 	sigs.k8s.io/yaml v1.3.0
@@ -210,7 +210,7 @@ require (
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	k8s.io/cli-runtime v0.28.3
 	k8s.io/kube-openapi v0.0.0-20230905202853-d090da108d2f // indirect
-	k8s.io/kubectl v0.28.2
+	k8s.io/kubectl v0.28.3
 	k8s.io/utils v0.0.0-20230726121419-3b25d923346b // indirect
 	sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect
 	sigs.k8s.io/kind v0.20.0 // indirect
diff --git a/go.sum b/go.sum
index 09ec3d345..3155d1b7f 100644
--- a/go.sum
+++ b/go.sum
@@ -675,20 +675,20 @@ k8s.io/cli-runtime v0.28.3 h1:lvuJYVkwCqHEvpS6KuTZsUVwPePFjBfSGvuaLl2SxzA=
 k8s.io/cli-runtime v0.28.3/go.mod h1:jeX37ZPjIcENVuXDDTskG3+FnVuZms5D9omDXS/2Jjc=
 k8s.io/client-go v0.28.3 h1:2OqNb72ZuTZPKCl+4gTKvqao0AMOl9f3o2ijbAj3LI4=
 k8s.io/client-go v0.28.3/go.mod h1:LTykbBp9gsA7SwqirlCXBWtK0guzfhpoW4qSm7i9dxo=
-k8s.io/component-base v0.28.2 h1:Yc1yU+6AQSlpJZyvehm/NkJBII72rzlEsd6MkBQ+G0E=
-k8s.io/component-base v0.28.2/go.mod h1:4IuQPQviQCg3du4si8GpMrhAIegxpsgPngPRR/zWpzc=
+k8s.io/component-base v0.28.3 h1:rDy68eHKxq/80RiMb2Ld/tbH8uAE75JdCqJyi6lXMzI=
+k8s.io/component-base v0.28.3/go.mod h1:fDJ6vpVNSk6cRo5wmDa6eKIG7UlIQkaFmZN2fYgIUD8=
 k8s.io/klog/v2 v2.100.1 h1:7WCHKK6K8fNhTqfBhISHQ97KrnJNFZMcQvKp7gP/tmg=
 k8s.io/klog/v2 v2.100.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0=
 k8s.io/kube-openapi v0.0.0-20230905202853-d090da108d2f h1:eeEUOoGYWhOz7EyXqhlR2zHKNw2mNJ9vzJmub6YN6kk=
 k8s.io/kube-openapi v0.0.0-20230905202853-d090da108d2f/go.mod h1:AsvuZPBlUDVuCdzJ87iajxtXuR9oktsTctW/R9wwouA=
-k8s.io/kubectl v0.28.2 h1:fOWOtU6S0smdNjG1PB9WFbqEIMlkzU5ahyHkc7ESHgM=
-k8s.io/kubectl v0.28.2/go.mod h1:6EQWTPySF1fn7yKoQZHYf9TPwIl2AygHEcJoxFekr64=
+k8s.io/kubectl v0.28.3 h1:H1Peu1O3EbN9zHkJCcvhiJ4NUj6lb88sGPO5wrWIM6k=
+k8s.io/kubectl v0.28.3/go.mod h1:RDAudrth/2wQ3Sg46fbKKl4/g+XImzvbsSRZdP2RiyE=
 k8s.io/utils v0.0.0-20230726121419-3b25d923346b h1:sgn3ZU783SCgtaSJjpcVVlRqd6GSnlTLKgpAAttJvpI=
 k8s.io/utils v0.0.0-20230726121419-3b25d923346b/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0=
 sigs.k8s.io/controller-runtime v0.16.2 h1:mwXAVuEk3EQf478PQwQ48zGOXvW27UJc8NHktQVuIPU=
 sigs.k8s.io/controller-runtime v0.16.2/go.mod h1:vpMu3LpI5sYWtujJOa2uPK61nB5rbwlN7BAB8aSLvGU=
-sigs.k8s.io/gateway-api v0.8.1 h1:Bo4NMAQFYkQZnHXOfufbYwbPW7b3Ic5NjpbeW6EJxuU=
-sigs.k8s.io/gateway-api v0.8.1/go.mod h1:0PteDrsrgkRmr13nDqFWnev8tOysAVrwnvfFM55tSVg=
+sigs.k8s.io/gateway-api v1.0.0-rc1 h1:v7N9fWTcQxox5aP2IrViDw6imeUHMAt2WFjI4BYo0sw=
+sigs.k8s.io/gateway-api v1.0.0-rc1/go.mod h1:+QpYENjk9s31/abu2Pv5BpK2v88UQDK2aeQCwCvy6ck=
 sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd h1:EDPBXCAspyGV4jQlpZSudPeMmr1bNJefnuqLsRAsHZo=
 sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd/go.mod h1:B8JuhiUyNFVKdsE8h686QcCxMaH6HrOAZj4vswFpcB0=
 sigs.k8s.io/kind v0.20.0 h1:f0sc3v9mQbGnjBUaqSFST1dwIuiikKVGgoTwpoP33a8=
diff --git a/internal/admission/handler.go b/internal/admission/handler.go
index a20da1643..174f4a1f0 100644
--- a/internal/admission/handler.go
+++ b/internal/admission/handler.go
@@ -11,7 +11,6 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	netv1 "k8s.io/api/networking/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/gatewayapi"
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/util"
@@ -91,16 +90,6 @@ var (
 		Version:  corev1.SchemeGroupVersion.Version,
 		Resource: "secrets",
 	}
-	gatewayGVResource = metav1.GroupVersionResource{
-		Group:    gatewayv1beta1.GroupVersion.Group,
-		Version:  gatewayv1beta1.GroupVersion.Version,
-		Resource: "gateways",
-	}
-	httprouteGVResource = metav1.GroupVersionResource{
-		Group:    gatewayv1beta1.GroupVersion.Group,
-		Version:  gatewayv1beta1.GroupVersion.Version,
-		Resource: "httproutes",
-	}
 	ingressGVResource = metav1.GroupVersionResource{
 		Group:    netv1.SchemeGroupVersion.Group,
 		Version:  netv1.SchemeGroupVersion.Version,
@@ -124,9 +113,9 @@ func (h RequestHandler) handleValidation(ctx context.Context, request admissionv
 		return h.handleKongClusterPlugin(ctx, request, responseBuilder)
 	case secretGVResource:
 		return h.handleSecret(ctx, request, responseBuilder)
-	case gatewayGVResource:
+	case gatewayapi.V1GatewayGVResource, gatewayapi.V1beta1GatewayGVResource:
 		return h.handleGateway(ctx, request, responseBuilder)
-	case httprouteGVResource:
+	case gatewayapi.V1HTTPRouteGVResource, gatewayapi.V1beta1HTTPRouteGVResource:
 		return h.handleHTTPRoute(ctx, request, responseBuilder)
 	case kongIngressGVResource:
 		return h.handleKongIngress(ctx, request, responseBuilder)
diff --git a/internal/controllers/gateway/gateway_controller.go b/internal/controllers/gateway/gateway_controller.go
index b2662c611..69a22b43c 100644
--- a/internal/controllers/gateway/gateway_controller.go
+++ b/internal/controllers/gateway/gateway_controller.go
@@ -22,6 +22,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/source"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/annotations"
@@ -36,7 +37,7 @@ import (
 // Vars & Consts
 // -----------------------------------------------------------------------------
 
-var gatewayV1beta1Group = gatewayapi.Group(gatewayv1beta1.GroupName)
+var gatewayV1Group = gatewayapi.Group(gatewayv1.GroupName)
 
 // -----------------------------------------------------------------------------
 // Gateway Controller - GatewayReconciler
@@ -329,7 +330,7 @@ func referenceGrantHasGatewayFrom(obj client.Object) bool {
 // Reconcile is part of the main kubernetes reconciliation loop which aims to
 // move the current state of the cluster closer to the desired state.
 func (r *GatewayReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
-	log := r.Log.WithValues("GatewayV1Beta1Gateway", req.NamespacedName)
+	log := r.Log.WithValues("GatewayV1Gateway", req.NamespacedName)
 
 	// gather the gateway object based on the reconciliation trigger. It's possible for the object
 	// to be gone at this point in which case it will be ignored.
@@ -646,8 +647,8 @@ func (r *GatewayReconciler) determineL4ListenersFromService(
 	addresses := make([]gatewayapi.GatewayAddress, 0, len(svc.Spec.ClusterIPs))
 	listeners := make([]gatewayapi.Listener, 0, len(svc.Spec.Ports))
 	protocolToRouteGroupKind := map[corev1.Protocol]gatewayapi.RouteGroupKind{
-		corev1.ProtocolTCP: {Group: &gatewayV1beta1Group, Kind: gatewayapi.Kind("TCPRoute")},
-		corev1.ProtocolUDP: {Group: &gatewayV1beta1Group, Kind: gatewayapi.Kind("UDPRoute")},
+		corev1.ProtocolTCP: {Group: &gatewayV1Group, Kind: gatewayapi.Kind("TCPRoute")},
+		corev1.ProtocolUDP: {Group: &gatewayV1Group, Kind: gatewayapi.Kind("UDPRoute")},
 	}
 
 	for _, port := range svc.Spec.Ports {
@@ -742,7 +743,7 @@ func (r *GatewayReconciler) determineListenersFromDataPlane(
 				listener.Protocol = gatewayapi.TLSProtocolType
 				listener.AllowedRoutes = &gatewayapi.AllowedRoutes{
 					Kinds: []gatewayapi.RouteGroupKind{
-						{Group: &gatewayV1beta1Group, Kind: (gatewayapi.Kind)("TLSRoute")},
+						{Group: &gatewayV1Group, Kind: (gatewayapi.Kind)("TLSRoute")},
 					},
 				}
 			}
@@ -752,14 +753,14 @@ func (r *GatewayReconciler) determineListenersFromDataPlane(
 				listener.Protocol = gatewayapi.HTTPSProtocolType
 				listener.AllowedRoutes = &gatewayapi.AllowedRoutes{
 					Kinds: []gatewayapi.RouteGroupKind{
-						{Group: &gatewayV1beta1Group, Kind: (gatewayapi.Kind)("HTTPRoute")},
+						{Group: &gatewayV1Group, Kind: (gatewayapi.Kind)("HTTPRoute")},
 					},
 				}
 			} else {
 				listener.Protocol = gatewayapi.HTTPProtocolType
 				listener.AllowedRoutes = &gatewayapi.AllowedRoutes{
 					Kinds: []gatewayapi.RouteGroupKind{
-						{Group: &gatewayV1beta1Group, Kind: (gatewayapi.Kind)("HTTPRoute")},
+						{Group: &gatewayV1Group, Kind: (gatewayapi.Kind)("HTTPRoute")},
 					},
 				}
 			}
diff --git a/internal/controllers/gateway/gateway_utils.go b/internal/controllers/gateway/gateway_utils.go
index a69ac233a..b96f8fb51 100644
--- a/internal/controllers/gateway/gateway_utils.go
+++ b/internal/controllers/gateway/gateway_utils.go
@@ -16,7 +16,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/event"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
-	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/annotations"
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/gatewayapi"
@@ -530,7 +530,7 @@ func getReferenceGrantConditionReason(
 		}
 		for _, from := range grant.Spec.From {
 			// we are interested only in grants for gateways that want to reference secrets
-			if from.Group != gatewayV1beta1Group || from.Kind != "Gateway" {
+			if from.Group != gatewayV1Group || from.Kind != "Gateway" {
 				continue
 			}
 			if from.Namespace == gatewayapi.Namespace(gatewayNamespace) {
@@ -617,7 +617,7 @@ func getListenerSupportedRouteKinds(l gatewayapi.Listener) ([]gatewayapi.RouteGr
 		reason       = gatewayapi.ListenerReasonResolvedRefs
 	)
 	for _, gk := range l.AllowedRoutes.Kinds {
-		if gk.Group != nil && *gk.Group == gatewayv1beta1.GroupName {
+		if gk.Group != nil && *gk.Group == gatewayv1.GroupName {
 			_, ok := lo.Find(supportedKinds, func(k gatewayapi.Kind) bool {
 				return gk.Kind == k
 			})
@@ -659,7 +659,7 @@ func routeAcceptedByGateways(routeNamespace string, parentStatuses []gatewayapi.
 	for _, routeParentStatus := range parentStatuses {
 		gatewayNamespace := routeNamespace
 		parentRef := routeParentStatus.ParentRef
-		if (parentRef.Group != nil && *parentRef.Group != gatewayV1beta1Group) ||
+		if (parentRef.Group != nil && *parentRef.Group != gatewayV1Group) ||
 			(parentRef.Kind != nil && *parentRef.Kind != "Gateway") {
 			continue
 		}
diff --git a/internal/controllers/gateway/gatewayclass_controller.go b/internal/controllers/gateway/gatewayclass_controller.go
index fb911c0f2..98170eb62 100644
--- a/internal/controllers/gateway/gatewayclass_controller.go
+++ b/internal/controllers/gateway/gatewayclass_controller.go
@@ -110,7 +110,7 @@ func (r *GatewayClassReconciler) GatewayClassIsUnmanaged(obj client.Object) bool
 // Reconcile is part of the main kubernetes reconciliation loop which aims to
 // move the current state of the cluster closer to the desired state.
 func (r *GatewayClassReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
-	log := r.Log.WithValues("GatewayV1Beta1GatewayClass", req.NamespacedName)
+	log := r.Log.WithValues("GatewayV1GatewayClass", req.NamespacedName)
 
 	gwc := new(gatewayapi.GatewayClass)
 	if err := r.Client.Get(ctx, req.NamespacedName, gwc); err != nil {
diff --git a/internal/controllers/gateway/httproute_controller.go b/internal/controllers/gateway/httproute_controller.go
index 0d6f777b2..d5914e4af 100644
--- a/internal/controllers/gateway/httproute_controller.go
+++ b/internal/controllers/gateway/httproute_controller.go
@@ -22,6 +22,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/source"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/controllers"
@@ -118,8 +119,8 @@ func (r *HTTPRouteReconciler) SetupWithManager(mgr ctrl.Manager) error {
 	if r.StatusQueue != nil {
 		if err := c.Watch(
 			&source.Channel{Source: r.StatusQueue.Subscribe(schema.GroupVersionKind{
-				Group:   gatewayv1beta1.GroupVersion.Group,
-				Version: gatewayv1beta1.GroupVersion.Version,
+				Group:   gatewayv1.GroupVersion.Group,
+				Version: gatewayv1.GroupVersion.Version,
 				Kind:    "HTTPRoute",
 			})},
 			&handler.EnqueueRequestForObject{},
@@ -330,7 +331,7 @@ func (r *HTTPRouteReconciler) listHTTPRoutesForGateway(ctx context.Context, obj
 // Reconcile is part of the main kubernetes reconciliation loop which aims to
 // move the current state of the cluster closer to the desired state.
 func (r *HTTPRouteReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
-	log := r.Log.WithValues("GatewayV1Beta1HTTPRoute", req.NamespacedName)
+	log := r.Log.WithValues("GatewayV1HTTPRoute", req.NamespacedName)
 
 	httproute := new(gatewayapi.HTTPRoute)
 	if err := r.Get(ctx, req.NamespacedName, httproute); err != nil {
@@ -518,7 +519,7 @@ func (r *HTTPRouteReconciler) ensureGatewayReferenceStatusAdded(ctx context.Cont
 		// build a new status for the parent Gateway
 		gatewayParentStatus := &gatewayapi.RouteParentStatus{
 			ParentRef: gatewayapi.ParentReference{
-				Group:     (*gatewayapi.Group)(&gatewayv1beta1.GroupVersion.Group),
+				Group:     (*gatewayapi.Group)(&gatewayv1.GroupVersion.Group),
 				Kind:      util.StringToGatewayAPIKindPtr(httprouteParentKind),
 				Namespace: (*gatewayapi.Namespace)(&gateway.gateway.Namespace),
 				Name:      gatewayapi.ObjectName(gateway.gateway.Name),
diff --git a/internal/controllers/gateway/route_utils.go b/internal/controllers/gateway/route_utils.go
index 702f0f141..56bad6324 100644
--- a/internal/controllers/gateway/route_utils.go
+++ b/internal/controllers/gateway/route_utils.go
@@ -14,8 +14,8 @@ import (
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
-	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/gatewayapi"
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/util"
@@ -481,8 +481,8 @@ func existsMatchingReadyListenerInStatus[T gatewayapi.RouteT](route T, listener
 			switch any(route).(type) {
 			case *gatewayapi.HTTPRoute:
 				gvk = schema.GroupVersionKind{
-					Group:   gatewayv1beta1.GroupVersion.Group,
-					Version: gatewayv1beta1.GroupVersion.Version,
+					Group:   gatewayv1.GroupVersion.Group,
+					Version: gatewayv1.GroupVersion.Version,
 					Kind:    "HTTPRoute",
 				}
 			default:
@@ -656,7 +656,7 @@ func isHTTPReferenceGranted(grantSpec gatewayapi.ReferenceGrantSpec, backendRef
 		backendRefKind = *backendRef.Kind
 	}
 	for _, from := range grantSpec.From {
-		if from.Group != gatewayv1beta1.GroupName || from.Kind != "HTTPRoute" || fromNamespace != string(from.Namespace) {
+		if from.Group != gatewayv1.GroupName || from.Kind != "HTTPRoute" || fromNamespace != string(from.Namespace) {
 			continue
 		}
 
@@ -753,7 +753,7 @@ func ensureParentsProgrammedCondition[
 					Namespace: lo.ToPtr(gatewayapi.Namespace(gateway.Namespace)),
 					Name:      gatewayapi.ObjectName(gateway.Name),
 					Kind:      lo.ToPtr(gatewayapi.Kind("Gateway")),
-					Group:     lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+					Group:     lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 					SectionName: func() *gatewayapi.SectionName {
 						// We don't need to check whether the listener matches route's spec
 						// because that should already be done via getSupportedGatewayForRoute
@@ -865,7 +865,7 @@ func isParentRefEqualToParent[
 	parentRef gatewayapi.ParentReference,
 	parent parentT,
 ) bool {
-	if *parentRef.Group != gatewayv1beta1.GroupName {
+	if *parentRef.Group != gatewayv1.GroupName {
 		return false
 	}
 	if *parentRef.Kind != "Gateway" {
diff --git a/internal/dataplane/parser/translate_tlsroute.go b/internal/dataplane/parser/translate_tlsroute.go
index 762194c9e..5202e5911 100644
--- a/internal/dataplane/parser/translate_tlsroute.go
+++ b/internal/dataplane/parser/translate_tlsroute.go
@@ -5,7 +5,7 @@ import (
 	"fmt"
 
 	"github.com/kong/go-kong/kong"
-	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/dataplane/parser/translators"
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/gatewayapi"
@@ -108,7 +108,7 @@ func (p *Parser) isTLSRoutePassthrough(tlsroute *gatewayapi.TLSRoute) (bool, err
 	for _, parentStatus := range tlsroute.Status.Parents {
 		parentRef := parentStatus.ParentRef
 
-		if parentRef.Group != nil && string(*parentRef.Group) != gatewayv1beta1.GroupName {
+		if parentRef.Group != nil && string(*parentRef.Group) != gatewayv1.GroupName {
 			continue
 		}
 
diff --git a/internal/gatewayapi/aliases.go b/internal/gatewayapi/aliases.go
index de058f2e7..521329394 100644
--- a/internal/gatewayapi/aliases.go
+++ b/internal/gatewayapi/aliases.go
@@ -1,6 +1,7 @@
 package gatewayapi
 
 import (
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 )
@@ -9,63 +10,63 @@ import (
 // one version of the Gateway API to another with minimal changes to the codebase.
 
 type (
-	AllowedRoutes             = gatewayv1beta1.AllowedRoutes
-	BackendObjectReference    = gatewayv1beta1.BackendObjectReference
-	BackendRef                = gatewayv1beta1.BackendRef
-	CommonRouteSpec           = gatewayv1beta1.CommonRouteSpec
-	Gateway                   = gatewayv1beta1.Gateway
-	GatewayAddress            = gatewayv1beta1.GatewayAddress
-	GatewayClass              = gatewayv1beta1.GatewayClass
-	GatewayClassSpec          = gatewayv1beta1.GatewayClassSpec
-	GatewayClassStatus        = gatewayv1beta1.GatewayClassStatus
-	GatewayController         = gatewayv1beta1.GatewayController
-	GatewayList               = gatewayv1beta1.GatewayList
-	GatewaySpec               = gatewayv1beta1.GatewaySpec
-	GatewayStatus             = gatewayv1beta1.GatewayStatus
-	GatewayStatusAddress      = gatewayv1beta1.GatewayStatusAddress
-	GatewayTLSConfig          = gatewayv1beta1.GatewayTLSConfig
-	Group                     = gatewayv1beta1.Group
-	HTTPBackendRef            = gatewayv1beta1.HTTPBackendRef
-	HTTPHeader                = gatewayv1beta1.HTTPHeader
-	HTTPHeaderFilter          = gatewayv1beta1.HTTPHeaderFilter
-	HTTPHeaderMatch           = gatewayv1beta1.HTTPHeaderMatch
-	HTTPHeaderName            = gatewayv1beta1.HTTPHeaderName
-	HTTPMethod                = gatewayv1beta1.HTTPMethod
-	HTTPPathMatch             = gatewayv1beta1.HTTPPathMatch
-	HTTPQueryParamMatch       = gatewayv1beta1.HTTPQueryParamMatch
-	HTTPRequestRedirectFilter = gatewayv1beta1.HTTPRequestRedirectFilter
-	HTTPRoute                 = gatewayv1beta1.HTTPRoute
-	HTTPRouteFilter           = gatewayv1beta1.HTTPRouteFilter
-	HTTPRouteList             = gatewayv1beta1.HTTPRouteList
-	HTTPRouteMatch            = gatewayv1beta1.HTTPRouteMatch
-	HTTPRouteRule             = gatewayv1beta1.HTTPRouteRule
-	HTTPRouteSpec             = gatewayv1beta1.HTTPRouteSpec
-	HTTPRouteStatus           = gatewayv1beta1.HTTPRouteStatus
-	Hostname                  = gatewayv1beta1.Hostname
-	Kind                      = gatewayv1beta1.Kind
-	Listener                  = gatewayv1beta1.Listener
-	ListenerConditionReason   = gatewayv1beta1.ListenerConditionReason
-	ListenerConditionType     = gatewayv1beta1.ListenerConditionType
-	ListenerStatus            = gatewayv1beta1.ListenerStatus
-	Namespace                 = gatewayv1beta1.Namespace
-	ObjectName                = gatewayv1beta1.ObjectName
-	ParentReference           = gatewayv1beta1.ParentReference
-	PathMatchType             = gatewayv1beta1.PathMatchType
-	PortNumber                = gatewayv1beta1.PortNumber
-	PreciseHostname           = gatewayv1beta1.PreciseHostname
-	ProtocolType              = gatewayv1beta1.ProtocolType
+	AllowedRoutes             = gatewayv1.AllowedRoutes
+	BackendObjectReference    = gatewayv1.BackendObjectReference
+	BackendRef                = gatewayv1.BackendRef
+	CommonRouteSpec           = gatewayv1.CommonRouteSpec
+	Gateway                   = gatewayv1.Gateway
+	GatewayAddress            = gatewayv1.GatewayAddress
+	GatewayClass              = gatewayv1.GatewayClass
+	GatewayClassSpec          = gatewayv1.GatewayClassSpec
+	GatewayClassStatus        = gatewayv1.GatewayClassStatus
+	GatewayController         = gatewayv1.GatewayController
+	GatewayList               = gatewayv1.GatewayList
+	GatewaySpec               = gatewayv1.GatewaySpec
+	GatewayStatus             = gatewayv1.GatewayStatus
+	GatewayStatusAddress      = gatewayv1.GatewayStatusAddress
+	GatewayTLSConfig          = gatewayv1.GatewayTLSConfig
+	Group                     = gatewayv1.Group
+	HTTPBackendRef            = gatewayv1.HTTPBackendRef
+	HTTPHeader                = gatewayv1.HTTPHeader
+	HTTPHeaderFilter          = gatewayv1.HTTPHeaderFilter
+	HTTPHeaderMatch           = gatewayv1.HTTPHeaderMatch
+	HTTPHeaderName            = gatewayv1.HTTPHeaderName
+	HTTPMethod                = gatewayv1.HTTPMethod
+	HTTPPathMatch             = gatewayv1.HTTPPathMatch
+	HTTPQueryParamMatch       = gatewayv1.HTTPQueryParamMatch
+	HTTPRequestRedirectFilter = gatewayv1.HTTPRequestRedirectFilter
+	HTTPRoute                 = gatewayv1.HTTPRoute
+	HTTPRouteFilter           = gatewayv1.HTTPRouteFilter
+	HTTPRouteList             = gatewayv1.HTTPRouteList
+	HTTPRouteMatch            = gatewayv1.HTTPRouteMatch
+	HTTPRouteRule             = gatewayv1.HTTPRouteRule
+	HTTPRouteSpec             = gatewayv1.HTTPRouteSpec
+	HTTPRouteStatus           = gatewayv1.HTTPRouteStatus
+	Hostname                  = gatewayv1.Hostname
+	Kind                      = gatewayv1.Kind
+	Listener                  = gatewayv1.Listener
+	ListenerConditionReason   = gatewayv1.ListenerConditionReason
+	ListenerConditionType     = gatewayv1.ListenerConditionType
+	ListenerStatus            = gatewayv1.ListenerStatus
+	Namespace                 = gatewayv1.Namespace
+	ObjectName                = gatewayv1.ObjectName
+	ParentReference           = gatewayv1.ParentReference
+	PathMatchType             = gatewayv1.PathMatchType
+	PortNumber                = gatewayv1.PortNumber
+	PreciseHostname           = gatewayv1.PreciseHostname
+	ProtocolType              = gatewayv1.ProtocolType
 	ReferenceGrant            = gatewayv1beta1.ReferenceGrant
 	ReferenceGrantFrom        = gatewayv1beta1.ReferenceGrantFrom
 	ReferenceGrantList        = gatewayv1beta1.ReferenceGrantList
 	ReferenceGrantSpec        = gatewayv1beta1.ReferenceGrantSpec
 	ReferenceGrantTo          = gatewayv1beta1.ReferenceGrantTo
-	RouteConditionReason      = gatewayv1beta1.RouteConditionReason
-	RouteGroupKind            = gatewayv1beta1.RouteGroupKind
-	RouteNamespaces           = gatewayv1beta1.RouteNamespaces
-	RouteParentStatus         = gatewayv1beta1.RouteParentStatus
-	RouteStatus               = gatewayv1beta1.RouteStatus
-	SecretObjectReference     = gatewayv1beta1.SecretObjectReference
-	SectionName               = gatewayv1beta1.SectionName
+	RouteConditionReason      = gatewayv1.RouteConditionReason
+	RouteGroupKind            = gatewayv1.RouteGroupKind
+	RouteNamespaces           = gatewayv1.RouteNamespaces
+	RouteParentStatus         = gatewayv1.RouteParentStatus
+	RouteStatus               = gatewayv1.RouteStatus
+	SecretObjectReference     = gatewayv1.SecretObjectReference
+	SectionName               = gatewayv1.SectionName
 
 	GRPCBackendRef      = gatewayv1alpha2.GRPCBackendRef
 	GRPCHeaderMatch     = gatewayv1alpha2.GRPCHeaderMatch
@@ -96,67 +97,67 @@ type (
 )
 
 const (
-	FullPathHTTPPathModifier              = gatewayv1beta1.FullPathHTTPPathModifier
-	GatewayClassConditionStatusAccepted   = gatewayv1beta1.GatewayClassConditionStatusAccepted
-	GatewayClassReasonAccepted            = gatewayv1beta1.GatewayClassReasonAccepted
-	GatewayConditionAccepted              = gatewayv1beta1.GatewayConditionAccepted
-	GatewayConditionProgrammed            = gatewayv1beta1.GatewayConditionProgrammed
-	GatewayReasonAccepted                 = gatewayv1beta1.GatewayReasonAccepted
-	GatewayReasonPending                  = gatewayv1beta1.GatewayReasonPending
-	GatewayReasonProgrammed               = gatewayv1beta1.GatewayReasonProgrammed
-	HTTPMethodDelete                      = gatewayv1beta1.HTTPMethodDelete
-	HTTPMethodGet                         = gatewayv1beta1.HTTPMethodGet
-	HTTPProtocolType                      = gatewayv1beta1.HTTPProtocolType
-	HTTPRouteFilterExtensionRef           = gatewayv1beta1.HTTPRouteFilterExtensionRef
-	HTTPRouteFilterRequestHeaderModifier  = gatewayv1beta1.HTTPRouteFilterRequestHeaderModifier
-	HTTPRouteFilterRequestMirror          = gatewayv1beta1.HTTPRouteFilterRequestMirror
-	HTTPRouteFilterRequestRedirect        = gatewayv1beta1.HTTPRouteFilterRequestRedirect
-	HTTPRouteFilterResponseHeaderModifier = gatewayv1beta1.HTTPRouteFilterResponseHeaderModifier
-	HTTPRouteFilterURLRewrite             = gatewayv1beta1.HTTPRouteFilterURLRewrite
-	HTTPSProtocolType                     = gatewayv1beta1.HTTPSProtocolType
-	HeaderMatchExact                      = gatewayv1beta1.HeaderMatchExact
-	HeaderMatchRegularExpression          = gatewayv1beta1.HeaderMatchRegularExpression
-	HostnameAddressType                   = gatewayv1beta1.HostnameAddressType
-	IPAddressType                         = gatewayv1beta1.IPAddressType
-	ListenerConditionAccepted             = gatewayv1beta1.ListenerConditionAccepted
-	ListenerConditionConflicted           = gatewayv1beta1.ListenerConditionConflicted
-	ListenerConditionProgrammed           = gatewayv1beta1.ListenerConditionProgrammed
-	ListenerConditionResolvedRefs         = gatewayv1beta1.ListenerConditionResolvedRefs
-	ListenerReasonAccepted                = gatewayv1beta1.ListenerReasonAccepted
-	ListenerReasonHostnameConflict        = gatewayv1beta1.ListenerReasonHostnameConflict
-	ListenerReasonInvalid                 = gatewayv1beta1.ListenerReasonInvalid
-	ListenerReasonInvalidCertificateRef   = gatewayv1beta1.ListenerReasonInvalidCertificateRef
-	ListenerReasonInvalidRouteKinds       = gatewayv1beta1.ListenerReasonInvalidRouteKinds
-	ListenerReasonNoConflicts             = gatewayv1beta1.ListenerReasonNoConflicts
-	ListenerReasonPortUnavailable         = gatewayv1beta1.ListenerReasonPortUnavailable
-	ListenerReasonProgrammed              = gatewayv1beta1.ListenerReasonProgrammed
-	ListenerReasonProtocolConflict        = gatewayv1beta1.ListenerReasonProtocolConflict
-	ListenerReasonRefNotPermitted         = gatewayv1beta1.ListenerReasonRefNotPermitted
-	ListenerReasonResolvedRefs            = gatewayv1beta1.ListenerReasonResolvedRefs
-	ListenerReasonUnsupportedProtocol     = gatewayv1beta1.ListenerReasonUnsupportedProtocol
-	NamespacesFromAll                     = gatewayv1beta1.NamespacesFromAll
-	NamespacesFromSame                    = gatewayv1beta1.NamespacesFromSame
-	NamespacesFromSelector                = gatewayv1beta1.NamespacesFromSelector
-	PathMatchExact                        = gatewayv1beta1.PathMatchExact
-	PathMatchPathPrefix                   = gatewayv1beta1.PathMatchPathPrefix
-	PathMatchRegularExpression            = gatewayv1beta1.PathMatchRegularExpression
-	QueryParamMatchExact                  = gatewayv1beta1.QueryParamMatchExact
-	QueryParamMatchRegularExpression      = gatewayv1beta1.QueryParamMatchRegularExpression
-	RouteConditionAccepted                = gatewayv1beta1.RouteConditionAccepted
-	RouteConditionResolvedRefs            = gatewayv1beta1.RouteConditionResolvedRefs
-	RouteReasonAccepted                   = gatewayv1beta1.RouteReasonAccepted
-	RouteReasonBackendNotFound            = gatewayv1beta1.RouteReasonBackendNotFound
-	RouteReasonInvalidKind                = gatewayv1beta1.RouteReasonInvalidKind
-	RouteReasonNoMatchingListenerHostname = gatewayv1beta1.RouteReasonNoMatchingListenerHostname
-	RouteReasonNoMatchingParent           = gatewayv1beta1.RouteReasonNoMatchingParent
-	RouteReasonNotAllowedByListeners      = gatewayv1beta1.RouteReasonNotAllowedByListeners
-	RouteReasonRefNotPermitted            = gatewayv1beta1.RouteReasonRefNotPermitted
-	RouteReasonResolvedRefs               = gatewayv1beta1.RouteReasonResolvedRefs
-	TCPProtocolType                       = gatewayv1beta1.TCPProtocolType
-	TLSModePassthrough                    = gatewayv1beta1.TLSModePassthrough
-	TLSModeTerminate                      = gatewayv1beta1.TLSModeTerminate
-	TLSProtocolType                       = gatewayv1beta1.TLSProtocolType
-	UDPProtocolType                       = gatewayv1beta1.UDPProtocolType
+	FullPathHTTPPathModifier              = gatewayv1.FullPathHTTPPathModifier
+	GatewayClassConditionStatusAccepted   = gatewayv1.GatewayClassConditionStatusAccepted
+	GatewayClassReasonAccepted            = gatewayv1.GatewayClassReasonAccepted
+	GatewayConditionAccepted              = gatewayv1.GatewayConditionAccepted
+	GatewayConditionProgrammed            = gatewayv1.GatewayConditionProgrammed
+	GatewayReasonAccepted                 = gatewayv1.GatewayReasonAccepted
+	GatewayReasonPending                  = gatewayv1.GatewayReasonPending
+	GatewayReasonProgrammed               = gatewayv1.GatewayReasonProgrammed
+	HTTPMethodDelete                      = gatewayv1.HTTPMethodDelete
+	HTTPMethodGet                         = gatewayv1.HTTPMethodGet
+	HTTPProtocolType                      = gatewayv1.HTTPProtocolType
+	HTTPRouteFilterExtensionRef           = gatewayv1.HTTPRouteFilterExtensionRef
+	HTTPRouteFilterRequestHeaderModifier  = gatewayv1.HTTPRouteFilterRequestHeaderModifier
+	HTTPRouteFilterRequestMirror          = gatewayv1.HTTPRouteFilterRequestMirror
+	HTTPRouteFilterRequestRedirect        = gatewayv1.HTTPRouteFilterRequestRedirect
+	HTTPRouteFilterResponseHeaderModifier = gatewayv1.HTTPRouteFilterResponseHeaderModifier
+	HTTPRouteFilterURLRewrite             = gatewayv1.HTTPRouteFilterURLRewrite
+	HTTPSProtocolType                     = gatewayv1.HTTPSProtocolType
+	HeaderMatchExact                      = gatewayv1.HeaderMatchExact
+	HeaderMatchRegularExpression          = gatewayv1.HeaderMatchRegularExpression
+	HostnameAddressType                   = gatewayv1.HostnameAddressType
+	IPAddressType                         = gatewayv1.IPAddressType
+	ListenerConditionAccepted             = gatewayv1.ListenerConditionAccepted
+	ListenerConditionConflicted           = gatewayv1.ListenerConditionConflicted
+	ListenerConditionProgrammed           = gatewayv1.ListenerConditionProgrammed
+	ListenerConditionResolvedRefs         = gatewayv1.ListenerConditionResolvedRefs
+	ListenerReasonAccepted                = gatewayv1.ListenerReasonAccepted
+	ListenerReasonHostnameConflict        = gatewayv1.ListenerReasonHostnameConflict
+	ListenerReasonInvalid                 = gatewayv1.ListenerReasonInvalid
+	ListenerReasonInvalidCertificateRef   = gatewayv1.ListenerReasonInvalidCertificateRef
+	ListenerReasonInvalidRouteKinds       = gatewayv1.ListenerReasonInvalidRouteKinds
+	ListenerReasonNoConflicts             = gatewayv1.ListenerReasonNoConflicts
+	ListenerReasonPortUnavailable         = gatewayv1.ListenerReasonPortUnavailable
+	ListenerReasonProgrammed              = gatewayv1.ListenerReasonProgrammed
+	ListenerReasonProtocolConflict        = gatewayv1.ListenerReasonProtocolConflict
+	ListenerReasonRefNotPermitted         = gatewayv1.ListenerReasonRefNotPermitted
+	ListenerReasonResolvedRefs            = gatewayv1.ListenerReasonResolvedRefs
+	ListenerReasonUnsupportedProtocol     = gatewayv1.ListenerReasonUnsupportedProtocol
+	NamespacesFromAll                     = gatewayv1.NamespacesFromAll
+	NamespacesFromSame                    = gatewayv1.NamespacesFromSame
+	NamespacesFromSelector                = gatewayv1.NamespacesFromSelector
+	PathMatchExact                        = gatewayv1.PathMatchExact
+	PathMatchPathPrefix                   = gatewayv1.PathMatchPathPrefix
+	PathMatchRegularExpression            = gatewayv1.PathMatchRegularExpression
+	QueryParamMatchExact                  = gatewayv1.QueryParamMatchExact
+	QueryParamMatchRegularExpression      = gatewayv1.QueryParamMatchRegularExpression
+	RouteConditionAccepted                = gatewayv1.RouteConditionAccepted
+	RouteConditionResolvedRefs            = gatewayv1.RouteConditionResolvedRefs
+	RouteReasonAccepted                   = gatewayv1.RouteReasonAccepted
+	RouteReasonBackendNotFound            = gatewayv1.RouteReasonBackendNotFound
+	RouteReasonInvalidKind                = gatewayv1.RouteReasonInvalidKind
+	RouteReasonNoMatchingListenerHostname = gatewayv1.RouteReasonNoMatchingListenerHostname
+	RouteReasonNoMatchingParent           = gatewayv1.RouteReasonNoMatchingParent
+	RouteReasonNotAllowedByListeners      = gatewayv1.RouteReasonNotAllowedByListeners
+	RouteReasonRefNotPermitted            = gatewayv1.RouteReasonRefNotPermitted
+	RouteReasonResolvedRefs               = gatewayv1.RouteReasonResolvedRefs
+	TCPProtocolType                       = gatewayv1.TCPProtocolType
+	TLSModePassthrough                    = gatewayv1.TLSModePassthrough
+	TLSModeTerminate                      = gatewayv1.TLSModeTerminate
+	TLSProtocolType                       = gatewayv1.TLSProtocolType
+	UDPProtocolType                       = gatewayv1.UDPProtocolType
 
 	GRPCMethodMatchExact             = gatewayv1alpha2.GRPCMethodMatchExact
 	GRPCMethodMatchRegularExpression = gatewayv1alpha2.GRPCMethodMatchRegularExpression
diff --git a/internal/gatewayapi/typemeta.go b/internal/gatewayapi/typemeta.go
new file mode 100644
index 000000000..2655a949b
--- /dev/null
+++ b/internal/gatewayapi/typemeta.go
@@ -0,0 +1,86 @@
+package gatewayapi
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
+	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
+	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
+)
+
+var V1GatewayTypeMeta = metav1.TypeMeta{
+	APIVersion: gatewayv1.GroupVersion.String(),
+	Kind:       "Gateway",
+}
+
+var V1beta1GatewayTypeMeta = metav1.TypeMeta{
+	APIVersion: gatewayv1beta1.GroupVersion.String(),
+	Kind:       "Gateway",
+}
+
+var V1GatewayClassTypeMeta = metav1.TypeMeta{
+	APIVersion: gatewayv1.GroupVersion.String(),
+	Kind:       "GatewayClass",
+}
+
+var V1beta1GatewayClassTypeMeta = metav1.TypeMeta{
+	APIVersion: gatewayv1beta1.GroupVersion.String(),
+	Kind:       "GatewayClass",
+}
+
+var V1HTTPRouteTypeMeta = metav1.TypeMeta{
+	APIVersion: gatewayv1.GroupVersion.String(),
+	Kind:       "HTTPRoute",
+}
+
+var V1beta1HTTPRouteTypeMeta = metav1.TypeMeta{
+	APIVersion: gatewayv1beta1.GroupVersion.String(),
+	Kind:       "HTTPRoute",
+}
+
+var ReferenceGrantTypeMeta = metav1.TypeMeta{
+	APIVersion: gatewayv1beta1.GroupVersion.String(),
+	Kind:       "ReferenceGrant",
+}
+
+var GRPCRouteTypeMeta = metav1.TypeMeta{
+	APIVersion: gatewayv1alpha2.GroupVersion.String(),
+	Kind:       "GRPCRoute",
+}
+
+var TCPRouteTypeMeta = metav1.TypeMeta{
+	APIVersion: gatewayv1alpha2.GroupVersion.String(),
+	Kind:       "TCPRoute",
+}
+
+var TLSRouteTypeMeta = metav1.TypeMeta{
+	APIVersion: gatewayv1alpha2.GroupVersion.String(),
+	Kind:       "TLSRoute",
+}
+
+var UDPRouteTypeMeta = metav1.TypeMeta{
+	APIVersion: gatewayv1alpha2.GroupVersion.String(),
+	Kind:       "UDPRoute",
+}
+
+var (
+	V1GatewayGVResource = metav1.GroupVersionResource{
+		Group:    gatewayv1.GroupVersion.Group,
+		Version:  gatewayv1.GroupVersion.Version,
+		Resource: "gateways",
+	}
+	V1HTTPRouteGVResource = metav1.GroupVersionResource{
+		Group:    gatewayv1.GroupVersion.Group,
+		Version:  gatewayv1.GroupVersion.Version,
+		Resource: "httproutes",
+	}
+	V1beta1GatewayGVResource = metav1.GroupVersionResource{
+		Group:    gatewayv1beta1.GroupVersion.Group,
+		Version:  gatewayv1beta1.GroupVersion.Version,
+		Resource: "gateways",
+	}
+	V1beta1HTTPRouteGVResource = metav1.GroupVersionResource{
+		Group:    gatewayv1beta1.GroupVersion.Group,
+		Version:  gatewayv1beta1.GroupVersion.Version,
+		Resource: "httproutes",
+	}
+)
diff --git a/internal/manager/controllerdef.go b/internal/manager/controllerdef.go
index 5e7b10dfe..a4e688074 100644
--- a/internal/manager/controllerdef.go
+++ b/internal/manager/controllerdef.go
@@ -7,6 +7,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 
@@ -280,8 +281,8 @@ func setupControllers(
 				Log:              ctrl.LoggerFrom(ctx).WithName("controllers").WithName("Dynamic/HTTPRoute"),
 				CacheSyncTimeout: c.CacheSyncTimeout,
 				RequiredCRDs: append(baseGatewayCRDs(), schema.GroupVersionResource{
-					Group:    gatewayv1beta1.GroupVersion.Group,
-					Version:  gatewayv1beta1.GroupVersion.Version,
+					Group:    gatewayv1.GroupVersion.Group,
+					Version:  gatewayv1.GroupVersion.Version,
 					Resource: "httproutes",
 				}),
 				Controller: &gateway.HTTPRouteReconciler{
@@ -410,13 +411,13 @@ func setupControllers(
 func baseGatewayCRDs() []schema.GroupVersionResource {
 	return []schema.GroupVersionResource{
 		{
-			Group:    gatewayv1beta1.GroupVersion.Group,
-			Version:  gatewayv1beta1.GroupVersion.Version,
+			Group:    gatewayv1.GroupVersion.Group,
+			Version:  gatewayv1.GroupVersion.Version,
 			Resource: "gateways",
 		},
 		{
-			Group:    gatewayv1beta1.GroupVersion.Group,
-			Version:  gatewayv1beta1.GroupVersion.Version,
+			Group:    gatewayv1.GroupVersion.Group,
+			Version:  gatewayv1.GroupVersion.Version,
 			Resource: "gatewayclasses",
 		},
 	}
diff --git a/internal/manager/scheme/scheme.go b/internal/manager/scheme/scheme.go
index c87addbee..2be20de98 100644
--- a/internal/manager/scheme/scheme.go
+++ b/internal/manager/scheme/scheme.go
@@ -4,6 +4,7 @@ import (
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 
@@ -42,5 +43,9 @@ func Get() (*runtime.Scheme, error) {
 		return nil, err
 	}
 
+	if err := gatewayv1.Install(scheme); err != nil {
+		return nil, err
+	}
+
 	return scheme, nil
 }
diff --git a/internal/store/fake_store.go b/internal/store/fake_store.go
index a2de71638..e2b59d869 100644
--- a/internal/store/fake_store.go
+++ b/internal/store/fake_store.go
@@ -15,6 +15,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/cli-runtime/pkg/printers"
 	"k8s.io/client-go/tools/cache"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 	"sigs.k8s.io/yaml"
@@ -241,13 +242,13 @@ func (objects FakeObjects) MarshalToYAML() ([]byte, error) {
 	typeToGVK := map[reflect.Type]schema.GroupVersionKind{
 		reflect.TypeOf(&netv1.Ingress{}):                       netv1.SchemeGroupVersion.WithKind("Ingress"),
 		reflect.TypeOf(&netv1.IngressClass{}):                  netv1.SchemeGroupVersion.WithKind("IngressClass"),
-		reflect.TypeOf(&gatewayapi.HTTPRoute{}):                gatewayv1beta1.SchemeGroupVersion.WithKind("HTTPRoute"),
+		reflect.TypeOf(&gatewayapi.HTTPRoute{}):                gatewayv1.SchemeGroupVersion.WithKind("HTTPRoute"),
 		reflect.TypeOf(&gatewayapi.UDPRoute{}):                 gatewayv1alpha2.SchemeGroupVersion.WithKind("UDPRoute"),
 		reflect.TypeOf(&gatewayapi.TCPRoute{}):                 gatewayv1alpha2.SchemeGroupVersion.WithKind("TCPRoute"),
 		reflect.TypeOf(&gatewayapi.TLSRoute{}):                 gatewayv1alpha2.SchemeGroupVersion.WithKind("TLSRoute"),
 		reflect.TypeOf(&gatewayapi.GRPCRoute{}):                gatewayv1alpha2.SchemeGroupVersion.WithKind("GRPCRoute"),
 		reflect.TypeOf(&gatewayapi.ReferenceGrant{}):           gatewayv1beta1.SchemeGroupVersion.WithKind("ReferenceGrant"),
-		reflect.TypeOf(&gatewayapi.Gateway{}):                  gatewayv1beta1.SchemeGroupVersion.WithKind("Gateway"),
+		reflect.TypeOf(&gatewayapi.Gateway{}):                  gatewayv1.SchemeGroupVersion.WithKind("Gateway"),
 		reflect.TypeOf(&kongv1beta1.TCPIngress{}):              kongv1beta1.SchemeGroupVersion.WithKind("TCPIngress"),
 		reflect.TypeOf(&kongv1beta1.UDPIngress{}):              kongv1beta1.SchemeGroupVersion.WithKind("UDPIngress"),
 		reflect.TypeOf(&kongv1alpha1.IngressClassParameters{}): kongv1alpha1.SchemeGroupVersion.WithKind("IngressClassParameters"),
diff --git a/internal/store/store.go b/internal/store/store.go
index 886f8a9cf..ec18b02fd 100644
--- a/internal/store/store.go
+++ b/internal/store/store.go
@@ -35,6 +35,7 @@ import (
 	yamlserializer "k8s.io/apimachinery/pkg/runtime/serializer/yaml"
 	"k8s.io/apimachinery/pkg/selection"
 	"k8s.io/client-go/tools/cache"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 	"sigs.k8s.io/yaml"
@@ -985,7 +986,7 @@ func mkObjFromGVK(gvk schema.GroupVersionKind) (runtime.Object, error) {
 	// ----------------------------------------------------------------------------
 	// Kubernetes Gateway APIs
 	// ----------------------------------------------------------------------------
-	case gatewayv1beta1.SchemeGroupVersion.WithKind("HTTPRoute"):
+	case gatewayv1.SchemeGroupVersion.WithKind("HTTPRoute"):
 		return &gatewayapi.HTTPRoute{}, nil
 	case gatewayv1alpha2.SchemeGroupVersion.WithKind("GRPCRoute"):
 		return &gatewayapi.GRPCRoute{}, nil
diff --git a/internal/util/builder/routegroupkind.go b/internal/util/builder/routegroupkind.go
index 39ba677ff..99571b8a0 100644
--- a/internal/util/builder/routegroupkind.go
+++ b/internal/util/builder/routegroupkind.go
@@ -2,7 +2,7 @@ package builder
 
 import (
 	"github.com/samber/lo"
-	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/gatewayapi"
 )
@@ -17,7 +17,7 @@ type RouteGroupKindBuilder struct {
 func NewRouteGroupKind() *RouteGroupKindBuilder {
 	return &RouteGroupKindBuilder{
 		routeGroupKind: gatewayapi.RouteGroupKind{
-			Group: lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupVersion.Group)),
+			Group: lo.ToPtr(gatewayapi.Group(gatewayv1.GroupVersion.Group)),
 		},
 	}
 }
diff --git a/internal/util/logging.go b/internal/util/logging.go
index dce43d2a1..d0b90d5e9 100644
--- a/internal/util/logging.go
+++ b/internal/util/logging.go
@@ -51,7 +51,7 @@ func MakeLogger(level string, formatter string, output io.Writer) (*zap.Logger,
 		return lvl >= logLevel
 	})
 
-	encoder, err := getZapEncoding(formatter)
+	encoder, err := GetZapEncoding(formatter)
 	if err != nil {
 		return nil, fmt.Errorf("setting log formatter failed: %w", err)
 	}
@@ -68,7 +68,7 @@ func getZapLevel(level string) (zapcore.Level, error) {
 	return res, nil
 }
 
-func getZapEncoding(typ string) (zapcore.Encoder, error) {
+func GetZapEncoding(typ string) (zapcore.Encoder, error) {
 	switch typ {
 	case "text", "console":
 		return zapcore.NewConsoleEncoder(zapcore.EncoderConfig{


Test patch:
diff --git a/internal/controllers/gateway/gateway_controller_test.go b/internal/controllers/gateway/gateway_controller_test.go
index 7a1bcb931..6eef1940d 100644
--- a/internal/controllers/gateway/gateway_controller_test.go
+++ b/internal/controllers/gateway/gateway_controller_test.go
@@ -418,7 +418,7 @@ func TestGetReferenceGrantConditionReason(t *testing.T) {
 					Spec: gatewayapi.ReferenceGrantSpec{
 						From: []gatewayapi.ReferenceGrantFrom{
 							{
-								Group:     gatewayV1beta1Group,
+								Group:     gatewayV1Group,
 								Kind:      "Gateway",
 								Namespace: "test",
 							},
@@ -468,7 +468,7 @@ func TestGetReferenceGrantConditionReason(t *testing.T) {
 							},
 							// good entry
 							{
-								Group:     gatewayV1beta1Group,
+								Group:     gatewayV1Group,
 								Kind:      "Gateway",
 								Namespace: "test",
 							},
@@ -500,7 +500,7 @@ func TestGetReferenceGrantConditionReason(t *testing.T) {
 					Spec: gatewayapi.ReferenceGrantSpec{
 						From: []gatewayapi.ReferenceGrantFrom{
 							{
-								Group:     gatewayV1beta1Group,
+								Group:     gatewayV1Group,
 								Kind:      "Gateway",
 								Namespace: "test",
 							},
diff --git a/internal/controllers/gateway/gateway_utils_test.go b/internal/controllers/gateway/gateway_utils_test.go
index 7f0678763..37a85409e 100644
--- a/internal/controllers/gateway/gateway_utils_test.go
+++ b/internal/controllers/gateway/gateway_utils_test.go
@@ -11,14 +11,14 @@ import (
 	k8stypes "k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/kubernetes/scheme"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
-	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/gatewayapi"
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/util/builder"
 )
 
 func init() {
-	if err := gatewayv1beta1.Install(scheme.Scheme); err != nil {
+	if err := gatewayv1.Install(scheme.Scheme); err != nil {
 		panic(err)
 	}
 }
@@ -84,7 +84,7 @@ func TestGetListenerSupportedRouteKinds(t *testing.T) {
 							Kind:  gatewayapi.Kind("UnknownKind"),
 						},
 						{
-							Group: &gatewayV1beta1Group,
+							Group: &gatewayV1Group,
 							Kind:  gatewayapi.Kind("HTTPRoute"),
 						},
 					},
@@ -92,7 +92,7 @@ func TestGetListenerSupportedRouteKinds(t *testing.T) {
 			},
 			expectedSupportedKinds: []gatewayapi.RouteGroupKind{
 				{
-					Group: &gatewayV1beta1Group,
+					Group: &gatewayV1Group,
 					Kind:  gatewayapi.Kind("HTTPRoute"),
 				},
 			},
diff --git a/internal/controllers/gateway/route_utils_test.go b/internal/controllers/gateway/route_utils_test.go
index 9d4fb195f..9c046fb7d 100644
--- a/internal/controllers/gateway/route_utils_test.go
+++ b/internal/controllers/gateway/route_utils_test.go
@@ -16,8 +16,7 @@ import (
 	k8stypes "k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	fakeclient "sigs.k8s.io/controller-runtime/pkg/client/fake"
-	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
-	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/gatewayapi"
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/util"
@@ -30,8 +29,8 @@ func init() {
 		fmt.Println("error while adding core1 scheme")
 		os.Exit(1)
 	}
-	if err := gatewayv1beta1.Install(scheme.Scheme); err != nil {
-		fmt.Println("error while adding gatewayv1beta1 scheme")
+	if err := gatewayv1.Install(scheme.Scheme); err != nil {
+		fmt.Println("error while adding gatewayv1 scheme")
 		os.Exit(1)
 	}
 }
@@ -253,14 +252,11 @@ func TestGetSupportedGatewayForRoute(t *testing.T) {
 		listenerName string
 	}
 
-	goodGroup := gatewayapi.Group(gatewayv1alpha2.GroupName)
+	goodGroup := gatewayapi.Group(gatewayv1.GroupName)
 	goodKind := gatewayapi.Kind("Gateway")
 	basicHTTPRoute := func() *gatewayapi.HTTPRoute {
 		return &gatewayapi.HTTPRoute{
-			TypeMeta: metav1.TypeMeta{
-				Kind:       "HTTPRoute",
-				APIVersion: gatewayv1beta1.GroupVersion.Group + "/" + gatewayv1beta1.GroupVersion.Version,
-			},
+			TypeMeta: gatewayapi.V1GatewayTypeMeta,
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "basic-httproute",
 				Namespace: "test-namespace",
@@ -288,10 +284,7 @@ func TestGetSupportedGatewayForRoute(t *testing.T) {
 	t.Run("HTTPRoute", func(t *testing.T) {
 		gatewayWithHTTP80Ready := func() *gatewayapi.Gateway {
 			return &gatewayapi.Gateway{
-				TypeMeta: metav1.TypeMeta{
-					APIVersion: gatewayv1beta1.GroupVersion.String(),
-					Kind:       "Gateway",
-				},
+				TypeMeta: gatewayapi.V1GatewayTypeMeta,
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "test-gateway",
 					Namespace: "test-namespace",
@@ -565,10 +558,7 @@ func TestGetSupportedGatewayForRoute(t *testing.T) {
 	t.Run("TCPRoute", func(t *testing.T) {
 		basicTCPRoute := func() *gatewayapi.TCPRoute {
 			return &gatewayapi.TCPRoute{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "TCPRoute",
-					APIVersion: gatewayv1alpha2.GroupVersion.String(),
-				},
+				TypeMeta: gatewayapi.TCPRouteTypeMeta,
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "basic-tcproute",
 					Namespace: "test-namespace",
@@ -588,10 +578,7 @@ func TestGetSupportedGatewayForRoute(t *testing.T) {
 		}
 		gatewayWithTCP80Ready := func() *gatewayapi.Gateway {
 			return &gatewayapi.Gateway{
-				TypeMeta: metav1.TypeMeta{
-					APIVersion: "gateway.networking.k8s.io/v1beta1",
-					Kind:       "Gateway",
-				},
+				TypeMeta: gatewayapi.V1GatewayTypeMeta,
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "test-gateway",
 					Namespace: "test-namespace",
@@ -772,10 +759,7 @@ func TestGetSupportedGatewayForRoute(t *testing.T) {
 	t.Run("UDPRoute", func(t *testing.T) {
 		basicUDPRoute := func() *gatewayapi.UDPRoute {
 			return &gatewayapi.UDPRoute{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "UDPRoute",
-					APIVersion: gatewayv1alpha2.GroupVersion.String(),
-				},
+				TypeMeta: gatewayapi.UDPRouteTypeMeta,
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "basic-udproute",
 					Namespace: "test-namespace",
@@ -795,10 +779,7 @@ func TestGetSupportedGatewayForRoute(t *testing.T) {
 		}
 		gatewayWithUDP53Ready := func() *gatewayapi.Gateway {
 			return &gatewayapi.Gateway{
-				TypeMeta: metav1.TypeMeta{
-					APIVersion: "gateway.networking.k8s.io/v1beta1",
-					Kind:       "Gateway",
-				},
+				TypeMeta: gatewayapi.V1GatewayTypeMeta,
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "test-gateway",
 					Namespace: "test-namespace",
@@ -959,10 +940,7 @@ func TestGetSupportedGatewayForRoute(t *testing.T) {
 	t.Run("TLSRoute", func(t *testing.T) {
 		basicTLSRoute := func() *gatewayapi.TLSRoute {
 			return &gatewayapi.TLSRoute{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "TLSRoute",
-					APIVersion: gatewayv1alpha2.GroupVersion.Group + "/" + gatewayv1alpha2.GroupVersion.Version,
-				},
+				TypeMeta: gatewayapi.TLSRouteTypeMeta,
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "basic-tlsroute",
 					Namespace: "test-namespace",
@@ -982,10 +960,7 @@ func TestGetSupportedGatewayForRoute(t *testing.T) {
 		}
 		gatewayWithTLS443PassthroughReady := func() *gatewayapi.Gateway {
 			return &gatewayapi.Gateway{
-				TypeMeta: metav1.TypeMeta{
-					APIVersion: "gateway.networking.k8s.io/v1beta1",
-					Kind:       "Gateway",
-				},
+				TypeMeta: gatewayapi.V1GatewayTypeMeta,
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "test-gateway",
 					Namespace: "test-namespace",
@@ -1209,10 +1184,7 @@ func TestGetSupportedGatewayForRoute(t *testing.T) {
 func TestEnsureParentsProgrammedCondition(t *testing.T) {
 	createGateway := func(nn k8stypes.NamespacedName) *gatewayapi.Gateway {
 		return &gatewayapi.Gateway{
-			TypeMeta: metav1.TypeMeta{
-				APIVersion: gatewayv1beta1.GroupVersion.String(),
-				Kind:       "Gateway",
-			},
+			TypeMeta: gatewayapi.V1GatewayTypeMeta,
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      nn.Name,
 				Namespace: nn.Namespace,
@@ -1272,10 +1244,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 				name: "Programmed condition gets properly set to Status True when parent status is already set in route",
 				httpRouteFunc: func() *gatewayapi.HTTPRoute {
 					return &gatewayapi.HTTPRoute{
-						TypeMeta: metav1.TypeMeta{
-							Kind:       "HTTPRoute",
-							APIVersion: gatewayv1beta1.GroupVersion.Group + "/" + gatewayv1beta1.GroupVersion.Version,
-						},
+						TypeMeta: gatewayapi.V1HTTPRouteTypeMeta,
 						ObjectMeta: metav1.ObjectMeta{
 							Name:       "basic-httproute",
 							Namespace:  gatewayNN1.Namespace,
@@ -1285,7 +1254,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 							CommonRouteSpec: gatewayapi.CommonRouteSpec{
 								ParentRefs: []gatewayapi.ParentReference{
 									{
-										Group: lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+										Group: lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 										Kind:  lo.ToPtr(gatewayapi.Kind("Gateway")),
 										Name:  "test-gateway",
 									},
@@ -1305,7 +1274,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 									{
 										ParentRef: gatewayapi.ParentReference{
 											Kind:      lo.ToPtr(gatewayapi.Kind("Gateway")),
-											Group:     lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+											Group:     lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 											Name:      gatewayapi.ObjectName(gatewayNN1.Name),
 											Namespace: (*gatewayapi.Namespace)(&gatewayNN1.Namespace),
 										},
@@ -1341,7 +1310,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 							{
 								ParentRef: gatewayapi.ParentReference{
 									Kind:      lo.ToPtr(gatewayapi.Kind("Gateway")),
-									Group:     lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+									Group:     lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 									Name:      gatewayapi.ObjectName(gatewayNN1.Name),
 									Namespace: (*gatewayapi.Namespace)(&gatewayNN1.Namespace),
 								},
@@ -1378,10 +1347,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 				name: "Programmed condition gets properly set to Status True when Programmed condition is not present in route's parent status",
 				httpRouteFunc: func() *gatewayapi.HTTPRoute {
 					return &gatewayapi.HTTPRoute{
-						TypeMeta: metav1.TypeMeta{
-							Kind:       "HTTPRoute",
-							APIVersion: gatewayv1beta1.GroupVersion.Group + "/" + gatewayv1beta1.GroupVersion.Version,
-						},
+						TypeMeta: gatewayapi.V1HTTPRouteTypeMeta,
 						ObjectMeta: metav1.ObjectMeta{
 							Name:       "basic-httproute",
 							Namespace:  gatewayNN1.Namespace,
@@ -1391,7 +1357,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 							CommonRouteSpec: gatewayapi.CommonRouteSpec{
 								ParentRefs: []gatewayapi.ParentReference{
 									{
-										Group: lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+										Group: lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 										Kind:  lo.ToPtr(gatewayapi.Kind("Gateway")),
 										Name:  "test-gateway",
 									},
@@ -1411,7 +1377,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 									{
 										ParentRef: gatewayapi.ParentReference{
 											Kind:      lo.ToPtr(gatewayapi.Kind("Gateway")),
-											Group:     lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+											Group:     lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 											Name:      gatewayapi.ObjectName(gatewayNN1.Name),
 											Namespace: (*gatewayapi.Namespace)(&gatewayNN1.Namespace),
 										},
@@ -1439,7 +1405,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 							{
 								ParentRef: gatewayapi.ParentReference{
 									Kind:      lo.ToPtr(gatewayapi.Kind("Gateway")),
-									Group:     lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+									Group:     lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 									Name:      gatewayapi.ObjectName(gatewayNN1.Name),
 									Namespace: (*gatewayapi.Namespace)(&gatewayNN1.Namespace),
 								},
@@ -1476,10 +1442,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 				name: "Programmed condition gets properly set to Status True when Programmed condition is not present in route's parent status and Parent Section is specified",
 				httpRouteFunc: func() *gatewayapi.HTTPRoute {
 					return &gatewayapi.HTTPRoute{
-						TypeMeta: metav1.TypeMeta{
-							Kind:       "HTTPRoute",
-							APIVersion: gatewayv1beta1.GroupVersion.Group + "/" + gatewayv1beta1.GroupVersion.Version,
-						},
+						TypeMeta: gatewayapi.V1HTTPRouteTypeMeta,
 						ObjectMeta: metav1.ObjectMeta{
 							Name:       "basic-httproute",
 							Namespace:  gatewayNN1.Namespace,
@@ -1489,7 +1452,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 							CommonRouteSpec: gatewayapi.CommonRouteSpec{
 								ParentRefs: []gatewayapi.ParentReference{
 									{
-										Group:       lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+										Group:       lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 										Kind:        lo.ToPtr(gatewayapi.Kind("Gateway")),
 										Name:        "test-gateway",
 										SectionName: lo.ToPtr(gatewayapi.SectionName("http-2")),
@@ -1510,7 +1473,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 									{
 										ParentRef: gatewayapi.ParentReference{
 											Kind:        lo.ToPtr(gatewayapi.Kind("Gateway")),
-											Group:       lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+											Group:       lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 											Name:        gatewayapi.ObjectName(gatewayNN1.Name),
 											Namespace:   (*gatewayapi.Namespace)(&gatewayNN1.Namespace),
 											SectionName: lo.ToPtr(gatewayapi.SectionName("http-2")),
@@ -1530,7 +1493,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 							{
 								ParentRef: gatewayapi.ParentReference{
 									Kind:        lo.ToPtr(gatewayapi.Kind("Gateway")),
-									Group:       lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+									Group:       lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 									Name:        gatewayapi.ObjectName(gatewayNN1.Name),
 									Namespace:   (*gatewayapi.Namespace)(&gatewayNN1.Namespace),
 									SectionName: lo.ToPtr(gatewayapi.SectionName("http-2")),
@@ -1563,10 +1526,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 				name: "Programmed condition gets properly set to Status True when route's parent status is not set and Parent Section is specified with 2 gateways both with section name specified",
 				httpRouteFunc: func() *gatewayapi.HTTPRoute {
 					return &gatewayapi.HTTPRoute{
-						TypeMeta: metav1.TypeMeta{
-							Kind:       "HTTPRoute",
-							APIVersion: gatewayv1beta1.GroupVersion.Group + "/" + gatewayv1beta1.GroupVersion.Version,
-						},
+						TypeMeta: gatewayapi.V1HTTPRouteTypeMeta,
 						ObjectMeta: metav1.ObjectMeta{
 							Name:       "basic-httproute",
 							Namespace:  gatewayNN1.Namespace,
@@ -1576,13 +1536,13 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 							CommonRouteSpec: gatewayapi.CommonRouteSpec{
 								ParentRefs: []gatewayapi.ParentReference{
 									{
-										Group:       lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+										Group:       lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 										Kind:        lo.ToPtr(gatewayapi.Kind("Gateway")),
 										Name:        gatewayapi.ObjectName(gateway1.Name),
 										SectionName: lo.ToPtr(gatewayapi.SectionName("http-2")),
 									},
 									{
-										Group:       lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+										Group:       lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 										Kind:        lo.ToPtr(gatewayapi.Kind("Gateway")),
 										Name:        gatewayapi.ObjectName(gateway2.Name),
 										SectionName: lo.ToPtr(gatewayapi.SectionName("http-1")),
@@ -1607,7 +1567,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 							{
 								ParentRef: gatewayapi.ParentReference{
 									Kind:        lo.ToPtr(gatewayapi.Kind("Gateway")),
-									Group:       lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+									Group:       lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 									Name:        gatewayapi.ObjectName(gatewayNN1.Name),
 									Namespace:   (*gatewayapi.Namespace)(&gatewayNN1.Namespace),
 									SectionName: lo.ToPtr(gatewayapi.SectionName("http-2")),
@@ -1627,7 +1587,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 							{
 								ParentRef: gatewayapi.ParentReference{
 									Kind:        lo.ToPtr(gatewayapi.Kind("Gateway")),
-									Group:       lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+									Group:       lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 									Name:        gatewayapi.ObjectName(gatewayNN2.Name),
 									Namespace:   (*gatewayapi.Namespace)(&gatewayNN2.Namespace),
 									SectionName: lo.ToPtr(gatewayapi.SectionName("http-1")),
@@ -1664,10 +1624,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 				name: "Programmed condition gets properly added to route's parents status when no status for that parent is present yet",
 				httpRouteFunc: func() *gatewayapi.HTTPRoute {
 					return &gatewayapi.HTTPRoute{
-						TypeMeta: metav1.TypeMeta{
-							Kind:       "HTTPRoute",
-							APIVersion: gatewayv1beta1.GroupVersion.Group + "/" + gatewayv1beta1.GroupVersion.Version,
-						},
+						TypeMeta: gatewayapi.V1HTTPRouteTypeMeta,
 						ObjectMeta: metav1.ObjectMeta{
 							Name:       "basic-httproute",
 							Namespace:  gatewayNN1.Namespace,
@@ -1677,7 +1634,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 							CommonRouteSpec: gatewayapi.CommonRouteSpec{
 								ParentRefs: []gatewayapi.ParentReference{
 									{
-										Group: lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+										Group: lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 										Kind:  lo.ToPtr(gatewayapi.Kind("Gateway")),
 										Name:  "test-gateway",
 									},
@@ -1700,7 +1657,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 							{
 								ParentRef: gatewayapi.ParentReference{
 									Kind:      lo.ToPtr(gatewayapi.Kind("Gateway")),
-									Group:     lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+									Group:     lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 									Name:      gatewayapi.ObjectName(gatewayNN1.Name),
 									Namespace: (*gatewayapi.Namespace)(&gatewayNN1.Namespace),
 								},
@@ -1729,10 +1686,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 				name: "no update is being done when an expected Programmed condition is already in place",
 				httpRouteFunc: func() *gatewayapi.HTTPRoute {
 					return &gatewayapi.HTTPRoute{
-						TypeMeta: metav1.TypeMeta{
-							Kind:       "HTTPRoute",
-							APIVersion: gatewayv1beta1.GroupVersion.Group + "/" + gatewayv1beta1.GroupVersion.Version,
-						},
+						TypeMeta: gatewayapi.V1HTTPRouteTypeMeta,
 						ObjectMeta: metav1.ObjectMeta{
 							Name:       "basic-httproute",
 							Namespace:  gatewayNN1.Namespace,
@@ -1742,7 +1696,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 							CommonRouteSpec: gatewayapi.CommonRouteSpec{
 								ParentRefs: []gatewayapi.ParentReference{
 									{
-										Group: lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+										Group: lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 										Kind:  lo.ToPtr(gatewayapi.Kind("Gateway")),
 										Name:  "test-gateway",
 									},
@@ -1762,7 +1716,7 @@ func TestEnsureParentsProgrammedCondition(t *testing.T) {
 									{
 										ParentRef: gatewayapi.ParentReference{
 											Kind:      lo.ToPtr(gatewayapi.Kind("Gateway")),
-											Group:     lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupName)),
+											Group:     lo.ToPtr(gatewayapi.Group(gatewayv1.GroupName)),
 											Name:      gatewayapi.ObjectName(gatewayNN1.Name),
 											Namespace: (*gatewayapi.Namespace)(&gatewayNN1.Namespace),
 										},
diff --git a/internal/dataplane/kongstate/util_test.go b/internal/dataplane/kongstate/util_test.go
index 387fe57c2..7562d45c8 100644
--- a/internal/dataplane/kongstate/util_test.go
+++ b/internal/dataplane/kongstate/util_test.go
@@ -467,10 +467,7 @@ func TestGetKongIngressFromObjectMeta(t *testing.T) {
 		{
 			name: "konghq.com/override annotation does not affect Gateway API's TCPRoute",
 			route: &gatewayapi.TCPRoute{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "TCPRoute",
-					APIVersion: "gateway.networking.k8s.io/v1alpha2",
-				},
+				TypeMeta: gatewayapi.TCPRouteTypeMeta,
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "muntaxabi-jugrofiyai-umumiy",
 					Namespace: "behbudiy",
@@ -492,10 +489,7 @@ func TestGetKongIngressFromObjectMeta(t *testing.T) {
 		{
 			name: "konghq.com/override annotation does not affect Gateway API's UDPRoute",
 			route: &gatewayapi.UDPRoute{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "UDPRoute",
-					APIVersion: "gateway.networking.k8s.io/v1alpha2",
-				},
+				TypeMeta: gatewayapi.UDPRouteTypeMeta,
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "muntaxabi-jugrofiyai-umumiy",
 					Namespace: "behbudiy",
diff --git a/internal/dataplane/parser/testdata/golden/httproute-example/default_golden.yaml b/internal/dataplane/parser/testdata/golden/httproute-example/default_golden.yaml
index c926d5a02..f8508a3cf 100644
--- a/internal/dataplane/parser/testdata/golden/httproute-example/default_golden.yaml
+++ b/internal/dataplane/parser/testdata/golden/httproute-example/default_golden.yaml
@@ -26,13 +26,13 @@ services:
     - k8s-namespace:default
     - k8s-kind:HTTPRoute
     - k8s-group:gateway.networking.k8s.io
-    - k8s-version:v1beta1
+    - k8s-version:v1
   tags:
   - k8s-name:httproute-testing
   - k8s-namespace:default
   - k8s-kind:HTTPRoute
   - k8s-group:gateway.networking.k8s.io
-  - k8s-version:v1beta1
+  - k8s-version:v1
   write_timeout: 60000
 upstreams:
 - algorithm: round-robin
@@ -42,4 +42,4 @@ upstreams:
   - k8s-namespace:default
   - k8s-kind:HTTPRoute
   - k8s-group:gateway.networking.k8s.io
-  - k8s-version:v1beta1
+  - k8s-version:v1
diff --git a/internal/dataplane/parser/testdata/golden/httproute-example/expression-routes-on_golden.yaml b/internal/dataplane/parser/testdata/golden/httproute-example/expression-routes-on_golden.yaml
index e68cd9b21..7a24a31e4 100644
--- a/internal/dataplane/parser/testdata/golden/httproute-example/expression-routes-on_golden.yaml
+++ b/internal/dataplane/parser/testdata/golden/httproute-example/expression-routes-on_golden.yaml
@@ -21,13 +21,13 @@ services:
     - k8s-namespace:default
     - k8s-kind:HTTPRoute
     - k8s-group:gateway.networking.k8s.io
-    - k8s-version:v1beta1
+    - k8s-version:v1
   tags:
   - k8s-name:httproute-testing
   - k8s-namespace:default
   - k8s-kind:HTTPRoute
   - k8s-group:gateway.networking.k8s.io
-  - k8s-version:v1beta1
+  - k8s-version:v1
   write_timeout: 60000
 upstreams:
 - algorithm: round-robin
@@ -37,4 +37,4 @@ upstreams:
   - k8s-namespace:default
   - k8s-kind:HTTPRoute
   - k8s-group:gateway.networking.k8s.io
-  - k8s-version:v1beta1
+  - k8s-version:v1
diff --git a/internal/dataplane/parser/testdata/golden/httproute-example/in.yaml b/internal/dataplane/parser/testdata/golden/httproute-example/in.yaml
index 73174ee0f..0d38f0e18 100644
--- a/internal/dataplane/parser/testdata/golden/httproute-example/in.yaml
+++ b/internal/dataplane/parser/testdata/golden/httproute-example/in.yaml
@@ -31,7 +31,7 @@ spec:
     app: nginx
   type: ClusterIP
 ---
-apiVersion: gateway.networking.k8s.io/v1beta1
+apiVersion: gateway.networking.k8s.io/v1
 kind: HTTPRoute
 metadata:
   name: httproute-testing
diff --git a/internal/dataplane/parser/testdata/golden/same-name-services-single-backend/default_golden.yaml b/internal/dataplane/parser/testdata/golden/same-name-services-single-backend/default_golden.yaml
index eb21855a6..e2af25940 100644
--- a/internal/dataplane/parser/testdata/golden/same-name-services-single-backend/default_golden.yaml
+++ b/internal/dataplane/parser/testdata/golden/same-name-services-single-backend/default_golden.yaml
@@ -26,13 +26,13 @@ services:
     - k8s-namespace:default
     - k8s-kind:HTTPRoute
     - k8s-group:gateway.networking.k8s.io
-    - k8s-version:v1beta1
+    - k8s-version:v1
   tags:
   - k8s-name:test
   - k8s-namespace:default
   - k8s-kind:HTTPRoute
   - k8s-group:gateway.networking.k8s.io
-  - k8s-version:v1beta1
+  - k8s-version:v1
   write_timeout: 60000
 upstreams:
 - algorithm: round-robin
@@ -42,7 +42,7 @@ upstreams:
   - k8s-namespace:default
   - k8s-kind:HTTPRoute
   - k8s-group:gateway.networking.k8s.io
-  - k8s-version:v1beta1
+  - k8s-version:v1
   targets:
   - target: 10.244.0.5:9443
     weight: 50
diff --git a/internal/dataplane/parser/testdata/golden/same-name-services-single-backend/in.yaml b/internal/dataplane/parser/testdata/golden/same-name-services-single-backend/in.yaml
index 6bb2b965c..23a7aac3b 100644
--- a/internal/dataplane/parser/testdata/golden/same-name-services-single-backend/in.yaml
+++ b/internal/dataplane/parser/testdata/golden/same-name-services-single-backend/in.yaml
@@ -13,7 +13,7 @@ spec:
   - group: ""
     kind: Service
 ---
-apiVersion: gateway.networking.k8s.io/v1beta1
+apiVersion: gateway.networking.k8s.io/v1
 kind: HTTPRoute
 metadata:
   name: test
diff --git a/test/conformance/gateway_conformance_test.go b/test/conformance/gateway_conformance_test.go
index 1a1b0bd13..fa66d543f 100644
--- a/test/conformance/gateway_conformance_test.go
+++ b/test/conformance/gateway_conformance_test.go
@@ -20,10 +20,16 @@ import (
 )
 
 var commonSkippedTests = []string{
-	// HTTP
+	// core conformance
+	// https://github.com/Kong/kubernetes-ingress-controller/issues/4916
+	tests.GatewaySecretInvalidReferenceGrant.ShortName,
+
 	// extended conformance
 	// https://github.com/Kong/kubernetes-ingress-controller/issues/4563
 	tests.GatewayWithAttachedRoutesWithPort8080.ShortName,
+	// https://github.com/Kong/kubernetes-ingress-controller/issues/4913
+	tests.GatewayStaticAddresses.ShortName,
+
 	tests.HTTPRouteRedirectPortAndScheme.ShortName,
 	// https://github.com/Kong/kubernetes-ingress-controller/issues/3681
 	tests.HTTPRouteRedirectPort.ShortName,
@@ -33,6 +39,10 @@ var commonSkippedTests = []string{
 	tests.HTTPRouteRequestMirror.ShortName,
 	// https://github.com/Kong/kubernetes-ingress-controller/issues/4165
 	tests.HTTPRouteRequestMultipleMirrors.ShortName,
+	// https://github.com/Kong/kubernetes-ingress-controller/issues/4914
+	tests.HTTPRouteTimeoutBackendRequest.ShortName,
+	// https://github.com/Kong/kubernetes-ingress-controller/issues/4915
+	tests.HTTPRouteTimeoutRequest.ShortName,
 
 	// experimental conformance
 	// https://github.com/Kong/kubernetes-ingress-controller/issues/3684
diff --git a/test/conformance/gateway_expermimental_conformance_test.go b/test/conformance/gateway_expermimental_conformance_test.go
index f6d75a547..da4e6f0f1 100644
--- a/test/conformance/gateway_expermimental_conformance_test.go
+++ b/test/conformance/gateway_expermimental_conformance_test.go
@@ -41,9 +41,9 @@ func TestGatewayExperimentalConformance(t *testing.T) {
 				CleanupBaseResources: !testenv.IsCI(),
 				BaseManifests:        conformanceTestsBaseManifests,
 				SupportedFeatures: sets.New(
-					suite.SupportHTTPRouteMethodMatching,
-					suite.SupportHTTPResponseHeaderModification,
 					suite.SupportHTTPRouteQueryParamMatching,
+					suite.SupportHTTPRouteMethodMatching,
+					suite.SupportHTTPRouteResponseHeaderModification,
 				),
 			},
 			ConformanceProfiles: sets.New(
diff --git a/test/conformance/suite_test.go b/test/conformance/suite_test.go
index fdf38ff4a..579a7af1d 100644
--- a/test/conformance/suite_test.go
+++ b/test/conformance/suite_test.go
@@ -23,6 +23,7 @@ import (
 	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/client-go/kubernetes"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 
@@ -115,6 +116,7 @@ func prepareEnvForGatewayConformanceTests(t *testing.T) (c client.Client, gatewa
 	require.NoError(t, err)
 	require.NoError(t, gatewayv1alpha2.AddToScheme(client.Scheme()))
 	require.NoError(t, gatewayv1beta1.AddToScheme(client.Scheme()))
+	require.NoError(t, gatewayv1.AddToScheme(client.Scheme()))
 
 	featureGateFlag := fmt.Sprintf("--feature-gates=%s", consts.DefaultFeatureGates)
 
diff --git a/test/consts/zz_generated_gateway.go b/test/consts/zz_generated_gateway.go
index 44dbbd553..a5b101e7d 100644
--- a/test/consts/zz_generated_gateway.go
+++ b/test/consts/zz_generated_gateway.go
@@ -4,8 +4,8 @@
 package consts
 
 const (
-	GatewayAPIVersion                   = "v0.8.1"
-	GatewayStandardCRDsKustomizeURL     = "github.com/kubernetes-sigs/gateway-api/config/crd/?ref=v0.8.1"
-	GatewayExperimentalCRDsKustomizeURL = "github.com/kubernetes-sigs/gateway-api/config/crd/experimental?ref=v0.8.1"
-	GatewayRawRepoURL                   = "https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v0.8.1"
+	GatewayAPIVersion                   = "v1.0.0-rc1"
+	GatewayStandardCRDsKustomizeURL     = "github.com/kubernetes-sigs/gateway-api/config/crd/?ref=v1.0.0-rc1"
+	GatewayExperimentalCRDsKustomizeURL = "github.com/kubernetes-sigs/gateway-api/config/crd/experimental?ref=v1.0.0-rc1"
+	GatewayRawRepoURL                   = "https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.0.0-rc1"
 )
diff --git a/test/e2e/features_test.go b/test/e2e/features_test.go
index d2be62cb9..16c952c3a 100644
--- a/test/e2e/features_test.go
+++ b/test/e2e/features_test.go
@@ -86,8 +86,8 @@ func TestWebhookUpdate(t *testing.T) {
 	t.Log("building test cluster and environment")
 	clusterBuilder := kind.NewBuilder()
 	clusterBuilder.WithConfigReader(strings.NewReader(webhookKINDConfig))
-	if v := testenv.ClusterVersion(); v != "" {
-		clusterVersion, err := semver.ParseTolerant(v)
+	if testenv.ClusterVersion() != "" {
+		clusterVersion, err := semver.ParseTolerant(testenv.ClusterVersion())
 		require.NoError(t, err)
 		t.Logf("k8s cluster version is set to %v", clusterVersion)
 		clusterBuilder.WithClusterVersion(clusterVersion)
@@ -285,7 +285,7 @@ func TestDeployAllInOneDBLESSGateway(t *testing.T) {
 
 	gc, err := gatewayclient.NewForConfig(env.Cluster().Config())
 	require.NoError(t, err)
-	gw, err = gc.GatewayV1beta1().Gateways(corev1.NamespaceDefault).Get(ctx, gw.Name, metav1.GetOptions{})
+	gw, err = gc.GatewayV1().Gateways(corev1.NamespaceDefault).Get(ctx, gw.Name, metav1.GetOptions{})
 	require.NoError(t, err)
 	gw.Spec.Listeners = append(gw.Spec.Listeners,
 		gatewayapi.Listener{
@@ -301,10 +301,10 @@ func TestDeployAllInOneDBLESSGateway(t *testing.T) {
 	)
 
 	t.Log("verifying that unsupported listeners indicate correct status")
-	gw, err = gc.GatewayV1beta1().Gateways(corev1.NamespaceDefault).Update(ctx, gw, metav1.UpdateOptions{})
+	gw, err = gc.GatewayV1().Gateways(corev1.NamespaceDefault).Update(ctx, gw, metav1.UpdateOptions{})
 	require.NoError(t, err)
 	require.Eventually(t, func() bool {
-		gw, err = gc.GatewayV1beta1().Gateways(corev1.NamespaceDefault).Get(ctx, gw.Name, metav1.GetOptions{})
+		gw, err = gc.GatewayV1().Gateways(corev1.NamespaceDefault).Get(ctx, gw.Name, metav1.GetOptions{})
 		var http, udp bool
 		for _, lstatus := range gw.Status.Listeners {
 			if lstatus.Name == "badhttp" {
@@ -343,7 +343,7 @@ func TestDeployAllInOneDBLESSGateway(t *testing.T) {
 		return http == udp == true
 	}, time.Minute*2, time.Second*5)
 
-	gw, err = gc.GatewayV1beta1().Gateways(corev1.NamespaceDefault).Get(ctx, gw.Name, metav1.GetOptions{})
+	gw, err = gc.GatewayV1().Gateways(corev1.NamespaceDefault).Get(ctx, gw.Name, metav1.GetOptions{})
 	require.NoError(t, err)
 
 	t.Logf("deploying Gateway APIs CRDs in experimental channel from %s", consts.GatewayExperimentalCRDsKustomizeURL)
diff --git a/test/e2e/helpers_gateway_test.go b/test/e2e/helpers_gateway_test.go
index 7d94a1437..07ab35a0e 100644
--- a/test/e2e/helpers_gateway_test.go
+++ b/test/e2e/helpers_gateway_test.go
@@ -49,7 +49,7 @@ func deployGateway(ctx context.Context, t *testing.T, env environments.Environme
 			ControllerName: gateway.GetControllerName(),
 		},
 	}
-	supportedGatewayClass, err = gc.GatewayV1beta1().GatewayClasses().Create(ctx, supportedGatewayClass, metav1.CreateOptions{})
+	supportedGatewayClass, err = gc.GatewayV1().GatewayClasses().Create(ctx, supportedGatewayClass, metav1.CreateOptions{})
 	require.NoError(t, err)
 
 	t.Log("deploying a gateway to the test cluster using unmanaged gateway mode")
@@ -66,7 +66,7 @@ func deployGateway(ctx context.Context, t *testing.T, env environments.Environme
 			}},
 		},
 	}
-	gw, err = gc.GatewayV1beta1().Gateways(corev1.NamespaceDefault).Create(ctx, gw, metav1.CreateOptions{})
+	gw, err = gc.GatewayV1().Gateways(corev1.NamespaceDefault).Create(ctx, gw, metav1.CreateOptions{})
 	require.NoError(t, err)
 	return gw
 }
@@ -78,7 +78,7 @@ func verifyGateway(ctx context.Context, t *testing.T, env environments.Environme
 
 	t.Log("verifying that the gateway receives a final programmed condition once reconciliation completes")
 	require.Eventually(t, func() bool {
-		gw, err = gc.GatewayV1beta1().Gateways(corev1.NamespaceDefault).Get(ctx, gw.Name, metav1.GetOptions{})
+		gw, err = gc.GatewayV1().Gateways(corev1.NamespaceDefault).Get(ctx, gw.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 		if ready := util.CheckCondition(
 			gw.Status.Conditions,
@@ -113,7 +113,7 @@ func deployGatewayWithTCPListener(ctx context.Context, t *testing.T, env environ
 			ControllerName: gateway.GetControllerName(),
 		},
 	}
-	supportedGatewayClass, err = gc.GatewayV1beta1().GatewayClasses().Create(ctx, supportedGatewayClass, metav1.CreateOptions{})
+	supportedGatewayClass, err = gc.GatewayV1().GatewayClasses().Create(ctx, supportedGatewayClass, metav1.CreateOptions{})
 	require.NoError(t, err)
 
 	t.Log("deploying a gateway to the test cluster using unmanaged gateway mode")
@@ -137,16 +137,16 @@ func deployGatewayWithTCPListener(ctx context.Context, t *testing.T, env environ
 			},
 		},
 	}
-	_, err = gc.GatewayV1beta1().Gateways(corev1.NamespaceDefault).Get(ctx, gw.Name, metav1.GetOptions{})
+	_, err = gc.GatewayV1().Gateways(corev1.NamespaceDefault).Get(ctx, gw.Name, metav1.GetOptions{})
 	if err == nil {
 		t.Logf("gateway %s exists, delete and re-create it", gw.Name)
-		err = gc.GatewayV1beta1().Gateways(corev1.NamespaceDefault).Delete(ctx, gw.Name, metav1.DeleteOptions{})
+		err = gc.GatewayV1().Gateways(corev1.NamespaceDefault).Delete(ctx, gw.Name, metav1.DeleteOptions{})
 		require.NoError(t, err)
-		gw, err = gc.GatewayV1beta1().Gateways(corev1.NamespaceDefault).Create(ctx, gw, metav1.CreateOptions{})
+		gw, err = gc.GatewayV1().Gateways(corev1.NamespaceDefault).Create(ctx, gw, metav1.CreateOptions{})
 		require.NoError(t, err)
 	} else {
 		require.True(t, apierrors.IsNotFound(err))
-		gw, err = gc.GatewayV1beta1().Gateways(corev1.NamespaceDefault).Create(ctx, gw, metav1.CreateOptions{})
+		gw, err = gc.GatewayV1().Gateways(corev1.NamespaceDefault).Create(ctx, gw, metav1.CreateOptions{})
 		require.NoError(t, err)
 	}
 	return gw
@@ -203,7 +203,7 @@ func deployHTTPRoute(ctx context.Context, t *testing.T, env environments.Environ
 			}},
 		},
 	}
-	_, err = gc.GatewayV1beta1().HTTPRoutes(corev1.NamespaceDefault).Create(ctx, httproute, metav1.CreateOptions{})
+	_, err = gc.GatewayV1().HTTPRoutes(corev1.NamespaceDefault).Create(ctx, httproute, metav1.CreateOptions{})
 	require.NoError(t, err)
 }
 
diff --git a/test/envtest/gatewayclass_envtest_test.go b/test/envtest/gatewayclass_envtest_test.go
index 5e677765d..f6683971e 100644
--- a/test/envtest/gatewayclass_envtest_test.go
+++ b/test/envtest/gatewayclass_envtest_test.go
@@ -13,9 +13,9 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	k8stypes "k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/intstr"
-	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 	gatewayclient "sigs.k8s.io/gateway-api/pkg/client/clientset/versioned"
-	gatewayclientv1beta1 "sigs.k8s.io/gateway-api/pkg/client/clientset/versioned/typed/apis/v1beta1"
+	gatewayclientv1 "sigs.k8s.io/gateway-api/pkg/client/clientset/versioned/typed/apis/v1"
 
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/annotations"
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/controllers/gateway"
@@ -50,7 +50,7 @@ func TestGatewayWithGatewayClassReconciliation(t *testing.T) {
 		Test         func(
 			ctx context.Context,
 			t *testing.T,
-			gwClient gatewayclientv1beta1.GatewayInterface,
+			gwClient gatewayclientv1.GatewayInterface,
 			gwc gatewayapi.GatewayClass,
 			gw gatewayapi.Gateway,
 		)
@@ -81,7 +81,7 @@ func TestGatewayWithGatewayClassReconciliation(t *testing.T) {
 			Test: func(
 				ctx context.Context,
 				t *testing.T,
-				gwClient gatewayclientv1beta1.GatewayInterface,
+				gwClient gatewayclientv1.GatewayInterface,
 				gwc gatewayapi.GatewayClass,
 				gw gatewayapi.Gateway,
 			) {
@@ -137,7 +137,7 @@ func TestGatewayWithGatewayClassReconciliation(t *testing.T) {
 			Test: func(
 				ctx context.Context,
 				t *testing.T,
-				gwClient gatewayclientv1beta1.GatewayInterface,
+				gwClient gatewayclientv1.GatewayInterface,
 				gwc gatewayapi.GatewayClass,
 				gw gatewayapi.Gateway,
 			) {
@@ -211,7 +211,7 @@ func TestGatewayWithGatewayClassReconciliation(t *testing.T) {
 			Test: func(
 				ctx context.Context,
 				t *testing.T,
-				gwClient gatewayclientv1beta1.GatewayInterface,
+				gwClient gatewayclientv1.GatewayInterface,
 				gwc gatewayapi.GatewayClass,
 				gw gatewayapi.Gateway,
 			) {
@@ -245,7 +245,7 @@ func TestGatewayWithGatewayClassReconciliation(t *testing.T) {
 				w, err := gwClient.Watch(ctx, metav1.ListOptions{
 					FieldSelector: "metadata.name=" + gw.Name,
 					TypeMeta: metav1.TypeMeta{
-						APIVersion: gatewayv1beta1.GroupVersion.String(),
+						APIVersion: gatewayv1.GroupVersion.String(),
 						Kind:       "Gateway",
 					},
 				})
@@ -331,7 +331,7 @@ func TestGatewayWithGatewayClassReconciliation(t *testing.T) {
 			require.NoError(t, client.Create(ctx, &tc.Gateway))
 			t.Cleanup(func() { _ = client.Delete(ctx, &tc.Gateway) })
 
-			gwClient := gatewayClient.GatewayV1beta1().Gateways(ns.Name)
+			gwClient := gatewayClient.GatewayV1().Gateways(ns.Name)
 			tc.Test(ctx, t, gwClient, tc.GatewayClass, tc.Gateway)
 		})
 	}
diff --git a/test/envtest/httproute_controller_test.go b/test/envtest/httproute_controller_test.go
index 8fd891474..1891c37e0 100644
--- a/test/envtest/httproute_controller_test.go
+++ b/test/envtest/httproute_controller_test.go
@@ -18,7 +18,7 @@ import (
 	k8stypes "k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"
-	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/controllers/gateway"
 	"github.com/kong/kubernetes-ingress-controller/v2/internal/gatewayapi"
@@ -150,7 +150,7 @@ func TestHTTPRouteReconcilerProperlyReactsToReferenceGrant(t *testing.T) {
 				},
 				SupportedKinds: []gatewayapi.RouteGroupKind{
 					{
-						Group: lo.ToPtr(gatewayapi.Group(gatewayv1beta1.GroupVersion.Group)),
+						Group: lo.ToPtr(gatewayapi.Group(gatewayv1.GroupVersion.Group)),
 						Kind:  "HTTPRoute",
 					},
 				},
@@ -209,7 +209,7 @@ func TestHTTPRouteReconcilerProperlyReactsToReferenceGrant(t *testing.T) {
 		Spec: gatewayapi.ReferenceGrantSpec{
 			From: []gatewayapi.ReferenceGrantFrom{
 				{
-					Group:     gatewayapi.Group(gatewayv1beta1.GroupVersion.Group),
+					Group:     gatewayapi.Group(gatewayv1.GroupVersion.Group),
 					Kind:      "HTTPRoute",
 					Namespace: gatewayapi.Namespace(nsRoute.Name),
 				},
diff --git a/test/envtest/run.go b/test/envtest/run.go
index 2212d3e99..075a68303 100644
--- a/test/envtest/run.go
+++ b/test/envtest/run.go
@@ -11,6 +11,7 @@ import (
 	"github.com/phayes/freeport"
 	"github.com/samber/lo"
 	"github.com/samber/mo"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zaptest/observer"
@@ -184,9 +185,14 @@ func RunManager(
 	t.Cleanup(func() {
 		wg.Wait()
 		if t.Failed() {
+			encoder, err := util.GetZapEncoding("text")
+			require.NoError(t, err)
+
 			t.Logf("manager logs:")
 			for _, entry := range logs.All() {
-				t.Logf("%s - %s", entry.Time, entry.Message)
+				b, err := encoder.EncodeEntry(entry.Entry, entry.Context)
+				assert.NoError(t, err)
+				t.Logf("%s", b.String())
 			}
 		}
 	})
diff --git a/test/envtest/scheme.go b/test/envtest/scheme.go
index 219a36a4e..629b08659 100644
--- a/test/envtest/scheme.go
+++ b/test/envtest/scheme.go
@@ -6,6 +6,7 @@ import (
 	"github.com/stretchr/testify/require"
 	k8sruntime "k8s.io/apimachinery/pkg/runtime"
 	k8sscheme "k8s.io/client-go/kubernetes/scheme"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 	gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 
@@ -18,8 +19,9 @@ type SchemeOption func(t *testing.T, s *k8sruntime.Scheme)
 
 // WithGatewayAPI registers the Gateway API types with the scheme.
 func WithGatewayAPI(t *testing.T, s *k8sruntime.Scheme) {
-	require.NoError(t, gatewayv1beta1.AddToScheme(s))
-	require.NoError(t, gatewayv1alpha2.AddToScheme(s))
+	require.NoError(t, gatewayv1.Install(s))
+	require.NoError(t, gatewayv1beta1.Install(s))
+	require.NoError(t, gatewayv1alpha2.Install(s))
 }
 
 // WithKong registers the Kong types with the scheme.
diff --git a/test/envtest/telemetry_test.go b/test/envtest/telemetry_test.go
index d658ce87e..840812ae0 100644
--- a/test/envtest/telemetry_test.go
+++ b/test/envtest/telemetry_test.go
@@ -124,7 +124,7 @@ func createK8sObjectsForTelemetryTest(ctx context.Context, t *testing.T, cfg *re
 	require.NoError(t, err)
 
 	for i := 0; i < 2; i++ {
-		_, err = gcl.GatewayV1beta1().GatewayClasses().Create(
+		_, err = gcl.GatewayV1().GatewayClasses().Create(
 			ctx,
 			&gatewayapi.GatewayClass{
 				ObjectMeta: metav1.ObjectMeta{Name: fmt.Sprintf("test-%d", i)},
@@ -176,7 +176,7 @@ func createK8sObjectsForTelemetryTest(ctx context.Context, t *testing.T, cfg *re
 			)
 			require.NoError(t, err)
 
-			_, err = gcl.GatewayV1beta1().Gateways(namespace).Create(
+			_, err = gcl.GatewayV1().Gateways(namespace).Create(
 				ctx,
 				&gatewayapi.Gateway{
 					ObjectMeta: metav1.ObjectMeta{Name: fmt.Sprintf("test-%d", i)},
@@ -195,7 +195,7 @@ func createK8sObjectsForTelemetryTest(ctx context.Context, t *testing.T, cfg *re
 			)
 			require.NoError(t, err)
 
-			_, err = gcl.GatewayV1beta1().HTTPRoutes(namespace).Create(
+			_, err = gcl.GatewayV1().HTTPRoutes(namespace).Create(
 				ctx,
 				&gatewayapi.HTTPRoute{
 					ObjectMeta: metav1.ObjectMeta{Name: fmt.Sprintf("test-%d", i)},
diff --git a/test/integration/examples_test.go b/test/integration/examples_test.go
index 4632da8d1..d50bd7b99 100644
--- a/test/integration/examples_test.go
+++ b/test/integration/examples_test.go
@@ -51,7 +51,7 @@ func TestHTTPRouteExample(t *testing.T) {
 	t.Logf("verifying that the Gateway receives listen addresses")
 	var gatewayAddr string
 	require.Eventually(t, func() bool {
-		obj, err := gwc.GatewayV1beta1().Gateways(corev1.NamespaceDefault).Get(ctx, "kong", metav1.GetOptions{})
+		obj, err := gwc.GatewayV1().Gateways(corev1.NamespaceDefault).Get(ctx, "kong", metav1.GetOptions{})
 		if err != nil {
 			return false
 		}
diff --git a/test/integration/gateway_test.go b/test/integration/gateway_test.go
index 9a17f5238..41a9ae127 100644
--- a/test/integration/gateway_test.go
+++ b/test/integration/gateway_test.go
@@ -6,7 +6,6 @@ import (
 	"context"
 	"fmt"
 	"net/http"
-	"strings"
 	"testing"
 	"time"
 
@@ -65,20 +64,20 @@ func TestUnmanagedGatewayBasics(t *testing.T) {
 
 	t.Log("verifying that the gateway service ref gets provisioned when placeholder is used")
 	require.Eventually(t, func() bool {
-		gw, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Get(ctx, defaultGatewayName, metav1.GetOptions{})
+		gw, err = gatewayClient.GatewayV1().Gateways(ns.Name).Get(ctx, defaultGatewayName, metav1.GetOptions{})
 		require.NoError(t, err)
-		return gw.Annotations[annotations.AnnotationPrefix+annotations.GatewayPublishServiceKey] == strings.Join(
-			[]string{
-				fmt.Sprintf("%s/%s", pubsvc.Namespace, pubsvc.Name),
-				fmt.Sprintf("%s/%s", pubsvcUDP.Namespace, pubsvcUDP.Name),
-			},
-			",",
+		return lo.Contains(
+			annotations.ExtractGatewayPublishService(gw.Annotations),
+			fmt.Sprintf("%s/%s", pubsvc.Namespace, pubsvc.Name),
+		) && lo.Contains(
+			annotations.ExtractGatewayPublishService(gw.Annotations),
+			fmt.Sprintf("%s/%s", pubsvcUDP.Namespace, pubsvcUDP.Name),
 		)
 	}, gatewayUpdateWaitTime, time.Second)
 
 	t.Log("verifying that the gateway address is populated from the ingress service")
 	require.Eventually(t, func() bool {
-		gw, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
+		gw, err = gatewayClient.GatewayV1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 		addrs := make(map[string]bool, len(pubsvc.Status.LoadBalancer.Ingress))
 		for _, ing := range pubsvc.Status.LoadBalancer.Ingress {
@@ -102,14 +101,14 @@ func TestUnmanagedGatewayBasics(t *testing.T) {
 
 	t.Log("verifying that the gateway status gets updated to match the ingress service")
 	require.Eventually(t, func() bool {
-		gw, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
+		gw, err = gatewayClient.GatewayV1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 		return len(gw.Status.Listeners) == len(gw.Spec.Listeners) && len(gw.Status.Addresses) == len(gw.Spec.Addresses)
 	}, gatewayUpdateWaitTime, time.Second)
 
 	t.Log("verifying that the gateway receives a final programmed condition once reconciliation completes")
 	require.Eventually(t, func() bool {
-		gw, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
+		gw, err = gatewayClient.GatewayV1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 		ready := util.CheckCondition(
 			gw.Status.Conditions,
@@ -123,7 +122,7 @@ func TestUnmanagedGatewayBasics(t *testing.T) {
 
 	t.Log("verifying that the gateway listeners reach the programmed condition")
 	require.Eventually(t, func() bool {
-		gw, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
+		gw, err = gatewayClient.GatewayV1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 		for _, lstatus := range gw.Status.Listeners {
 			if listenerReady := util.CheckCondition(
@@ -177,7 +176,7 @@ func TestGatewayListenerConflicts(t *testing.T) {
 
 	t.Log("verifying that the gateway listeners reach the programmed condition")
 	require.Eventually(t, func() bool {
-		gw, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Get(ctx, defaultGatewayName, metav1.GetOptions{})
+		gw, err = gatewayClient.GatewayV1().Gateways(ns.Name).Get(ctx, defaultGatewayName, metav1.GetOptions{})
 		require.NoError(t, err)
 		for _, lstatus := range gw.Status.Listeners {
 			ready := util.CheckCondition(
@@ -203,14 +202,14 @@ func TestGatewayListenerConflicts(t *testing.T) {
 		},
 	)
 
-	_, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Update(ctx, gw, metav1.UpdateOptions{})
+	_, err = gatewayClient.GatewayV1().Gateways(ns.Name).Update(ctx, gw, metav1.UpdateOptions{})
 	require.NoError(t, err)
-	gw, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
+	gw, err = gatewayClient.GatewayV1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
 	require.NoError(t, err)
 
 	t.Log("confirming existing listen becomes unready and conflicted, new UDP listen has proto conflict")
 	require.Eventually(t, func() bool {
-		gw, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
+		gw, err = gatewayClient.GatewayV1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 		var badudpReady, badudpConflicted, httpReady, httpConflicted bool
 		for _, lstatus := range gw.Status.Listeners {
@@ -288,14 +287,14 @@ func TestGatewayListenerConflicts(t *testing.T) {
 		},
 	}
 
-	_, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Update(ctx, gw, metav1.UpdateOptions{})
+	_, err = gatewayClient.GatewayV1().Gateways(ns.Name).Update(ctx, gw, metav1.UpdateOptions{})
 	require.NoError(t, err)
-	gw, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
+	gw, err = gatewayClient.GatewayV1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
 	require.NoError(t, err)
 
 	t.Log("confirming existing listen remains ready and new listens become ready")
 	require.Eventually(t, func() bool {
-		gw, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
+		gw, err = gatewayClient.GatewayV1().Gateways(ns.Name).Get(ctx, gw.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 		var httpReady, tlsReady, httpsReady, httphostReady bool
 		for _, lstatus := range gw.Status.Listeners {
@@ -410,7 +409,7 @@ func TestGatewayFilters(t *testing.T) {
 		}
 	}
 
-	gatewayClient := gwClientSet.GatewayV1beta1()
+	gatewayClient := gwClientSet.GatewayV1()
 
 	httpRoute, err := gatewayClient.HTTPRoutes(ns.Name).Create(ctx, HTTPRoute(), metav1.CreateOptions{})
 	require.NoError(t, err)
diff --git a/test/integration/gateway_webhook_test.go b/test/integration/gateway_webhook_test.go
index 7acdf58da..bfbc2d263 100644
--- a/test/integration/gateway_webhook_test.go
+++ b/test/integration/gateway_webhook_test.go
@@ -86,7 +86,7 @@ func TestGatewayValidationWebhook(t *testing.T) {
 	} {
 		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
-			_, gotCreateErr := gatewayClient.GatewayV1beta1().Gateways(ns.Name).Create(ctx, &tt.createdGW, metav1.CreateOptions{})
+			_, gotCreateErr := gatewayClient.GatewayV1().Gateways(ns.Name).Create(ctx, &tt.createdGW, metav1.CreateOptions{})
 			if tt.wantCreateErr {
 				require.Error(t, gotCreateErr)
 				require.Contains(t, gotCreateErr.Error(), tt.wantCreateErrSubstring)
@@ -95,7 +95,7 @@ func TestGatewayValidationWebhook(t *testing.T) {
 			}
 
 			if len(tt.patch) > 0 {
-				_, gotUpdateErr := gatewayClient.GatewayV1beta1().Gateways(ns.Name).Patch(ctx, tt.createdGW.Name, k8stypes.MergePatchType, tt.patch, metav1.PatchOptions{})
+				_, gotUpdateErr := gatewayClient.GatewayV1().Gateways(ns.Name).Patch(ctx, tt.createdGW.Name, k8stypes.MergePatchType, tt.patch, metav1.PatchOptions{})
 				if tt.wantPatchErr {
 					require.Error(t, gotUpdateErr)
 					require.Contains(t, gotUpdateErr.Error(), tt.wantPatchErrSubstring)
@@ -104,7 +104,7 @@ func TestGatewayValidationWebhook(t *testing.T) {
 				}
 			}
 
-			if err := gatewayClient.GatewayV1beta1().Gateways(ns.Name).Delete(ctx, tt.createdGW.Name, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
+			if err := gatewayClient.GatewayV1().Gateways(ns.Name).Delete(ctx, tt.createdGW.Name, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
 				require.NoError(t, err)
 			}
 		})
diff --git a/test/integration/helpers_test.go b/test/integration/helpers_test.go
index 35685c80b..8611f09c0 100644
--- a/test/integration/helpers_test.go
+++ b/test/integration/helpers_test.go
@@ -44,7 +44,7 @@ func DeployGatewayClass(ctx context.Context, client *gatewayclient.Clientset, ga
 		ObjectMeta: metav1.ObjectMeta{
 			Name: gatewayClassName,
 			Annotations: map[string]string{
-				annotations.AnnotationPrefix + annotations.GatewayClassUnmanagedKey: annotations.GatewayClassUnmanagedAnnotationValuePlaceholder,
+				annotations.GatewayClassUnmanagedAnnotation: annotations.GatewayClassUnmanagedAnnotationValuePlaceholder,
 			},
 		},
 		Spec: gatewayapi.GatewayClassSpec{
@@ -56,13 +56,13 @@ func DeployGatewayClass(ctx context.Context, client *gatewayclient.Clientset, ga
 		opt(gwc)
 	}
 
-	result, err := client.GatewayV1beta1().GatewayClasses().Create(ctx, gwc, metav1.CreateOptions{})
+	result, err := client.GatewayV1().GatewayClasses().Create(ctx, gwc, metav1.CreateOptions{})
 	if apierrors.IsAlreadyExists(err) {
-		err = client.GatewayV1beta1().GatewayClasses().Delete(ctx, gwc.Name, metav1.DeleteOptions{})
+		err = client.GatewayV1().GatewayClasses().Delete(ctx, gwc.Name, metav1.DeleteOptions{})
 		if err != nil {
 			return result, err
 		}
-		result, err = client.GatewayV1beta1().GatewayClasses().Create(ctx, gwc, metav1.CreateOptions{})
+		result, err = client.GatewayV1().GatewayClasses().Create(ctx, gwc, metav1.CreateOptions{})
 	}
 	return result, err
 }
@@ -92,13 +92,13 @@ func DeployGateway(ctx context.Context, client *gatewayclient.Clientset, namespa
 		opt(gw)
 	}
 
-	result, err := client.GatewayV1beta1().Gateways(namespace).Create(ctx, gw, metav1.CreateOptions{})
+	result, err := client.GatewayV1().Gateways(namespace).Create(ctx, gw, metav1.CreateOptions{})
 	if apierrors.IsAlreadyExists(err) {
-		err = client.GatewayV1beta1().Gateways(namespace).Delete(ctx, gw.Name, metav1.DeleteOptions{})
+		err = client.GatewayV1().Gateways(namespace).Delete(ctx, gw.Name, metav1.DeleteOptions{})
 		if err != nil {
 			return result, err
 		}
-		result, err = client.GatewayV1beta1().Gateways(namespace).Create(ctx, gw, metav1.CreateOptions{})
+		result, err = client.GatewayV1().Gateways(namespace).Create(ctx, gw, metav1.CreateOptions{})
 	}
 	return result, err
 }
@@ -123,7 +123,7 @@ func gatewayHealthCheck(ctx context.Context, client *gatewayclient.Clientset, ga
 		case <-tick:
 			tick = nil
 			ch <- func() bool {
-				gw, err := client.GatewayV1beta1().Gateways(namespace).Get(ctx, gatewayName, metav1.GetOptions{})
+				gw, err := client.GatewayV1().Gateways(namespace).Get(ctx, gatewayName, metav1.GetOptions{})
 				exitOnErr(ctx, err)
 				ok := util.CheckCondition(
 					gw.Status.Conditions,
@@ -155,7 +155,7 @@ func HTTPRouteMatchesAcceptedCallback(t *testing.T, c *gatewayclient.Clientset,
 
 func httpRouteAcceptedConditionMatches(t *testing.T, c *gatewayclient.Clientset, httpRoute *gatewayapi.HTTPRoute, accepted bool, reason gatewayapi.RouteConditionReason) bool {
 	var err error
-	httpRoute, err = c.GatewayV1beta1().HTTPRoutes(httpRoute.Namespace).Get(context.Background(), httpRoute.Name, metav1.GetOptions{})
+	httpRoute, err = c.GatewayV1().HTTPRoutes(httpRoute.Namespace).Get(context.Background(), httpRoute.Name, metav1.GetOptions{})
 	require.NoError(t, err)
 
 	if len(httpRoute.Status.Parents) <= 0 {
@@ -183,7 +183,7 @@ func httpRouteAcceptedConditionMatches(t *testing.T, c *gatewayclient.Clientset,
 // each listener's name.
 func ListenersHaveNAttachedRoutesCallback(t *testing.T, c *gatewayclient.Clientset, namespace, gatewayName string, attachedRoutesByListener map[string]int32) func() bool {
 	return func() bool {
-		gateway, err := c.GatewayV1beta1().Gateways(namespace).Get(context.Background(), gatewayName, metav1.GetOptions{})
+		gateway, err := c.GatewayV1().Gateways(namespace).Get(context.Background(), gatewayName, metav1.GetOptions{})
 		assert.NoError(t, err)
 
 		for _, listenerStatus := range gateway.Status.Listeners {
@@ -264,7 +264,7 @@ func gatewayLinkStatusMatches(
 	// gather a fresh copy of the route, given the specific protocol type
 	switch protocolType { //nolint:exhaustive
 	case gatewayapi.HTTPProtocolType:
-		route, err := c.GatewayV1beta1().HTTPRoutes(namespace).Get(ctx, name, metav1.GetOptions{})
+		route, err := c.GatewayV1().HTTPRoutes(namespace).Get(ctx, name, metav1.GetOptions{})
 		groute, gerr := c.GatewayV1alpha2().GRPCRoutes(namespace).Get(ctx, name, metav1.GetOptions{})
 		if err != nil && gerr != nil {
 			t.Logf("error getting http route: %v", err)
@@ -348,7 +348,7 @@ func verifyProgrammedConditionStatus(t *testing.T,
 	// gather a fresh copy of the route, given the specific protocol type
 	switch protocolType { //nolint:exhaustive
 	case gatewayapi.HTTPProtocolType:
-		route, err := c.GatewayV1beta1().HTTPRoutes(namespace).Get(ctx, name, metav1.GetOptions{})
+		route, err := c.GatewayV1().HTTPRoutes(namespace).Get(ctx, name, metav1.GetOptions{})
 		groute, gerr := c.GatewayV1alpha2().GRPCRoutes(namespace).Get(ctx, name, metav1.GetOptions{})
 		if err != nil && gerr != nil {
 			t.Logf("error getting http route: %v", err)
diff --git a/test/integration/httproute_test.go b/test/integration/httproute_test.go
index 2a59511cd..5e7fdb6ac 100644
--- a/test/integration/httproute_test.go
+++ b/test/integration/httproute_test.go
@@ -142,7 +142,7 @@ func TestHTTPRouteEssentials(t *testing.T) {
 			}},
 		},
 	}
-	httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name).Create(ctx, httpRoute, metav1.CreateOptions{})
+	httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns.Name).Create(ctx, httpRoute, metav1.CreateOptions{})
 	require.NoError(t, err)
 	cleaner.Add(httpRoute)
 
@@ -178,7 +178,7 @@ func TestHTTPRouteEssentials(t *testing.T) {
 	}, ingressWait, waitTick)
 
 	t.Run("header regex match", func(t *testing.T) {
-		httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name).Get(ctx, httpRoute.Name, metav1.GetOptions{})
+		httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns.Name).Get(ctx, httpRoute.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 
 		httpRoute.Spec.Rules[0].Matches = append(httpRoute.Spec.Rules[0].Matches, gatewayapi.HTTPRouteMatch{
@@ -190,7 +190,7 @@ func TestHTTPRouteEssentials(t *testing.T) {
 				},
 			},
 		})
-		httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name).Update(ctx, httpRoute, metav1.UpdateOptions{})
+		httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns.Name).Update(ctx, httpRoute, metav1.UpdateOptions{})
 		require.NoError(t, err)
 
 		t.Log("verifying HTTPRoute header match")
@@ -200,7 +200,7 @@ func TestHTTPRouteEssentials(t *testing.T) {
 	t.Run("HTTPRoute query param match", func(t *testing.T) {
 		RunWhenKongExpressionRouter(t) //nolint:contextcheck
 
-		httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name).Get(ctx, httpRoute.Name, metav1.GetOptions{})
+		httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns.Name).Get(ctx, httpRoute.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 
 		httpRoute.Spec.Rules[0].Matches = append(httpRoute.Spec.Rules[0].Matches, gatewayapi.HTTPRouteMatch{
@@ -212,7 +212,7 @@ func TestHTTPRouteEssentials(t *testing.T) {
 				},
 			},
 		})
-		httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name).Update(ctx, httpRoute, metav1.UpdateOptions{})
+		httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns.Name).Update(ctx, httpRoute, metav1.UpdateOptions{})
 		require.NoError(t, err)
 
 		t.Log("verifying HTTPRoute query param match")
@@ -232,10 +232,10 @@ func TestHTTPRouteEssentials(t *testing.T) {
 	t.Log("removing the parentrefs from the HTTPRoute")
 	oldParentRefs := httpRoute.Spec.ParentRefs
 	require.Eventually(t, func() bool {
-		httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name).Get(ctx, httpRoute.Name, metav1.GetOptions{})
+		httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns.Name).Get(ctx, httpRoute.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 		httpRoute.Spec.ParentRefs = nil
-		httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name).Update(ctx, httpRoute, metav1.UpdateOptions{})
+		httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns.Name).Update(ctx, httpRoute, metav1.UpdateOptions{})
 		return err == nil
 	}, time.Minute, time.Second)
 
@@ -248,10 +248,10 @@ func TestHTTPRouteEssentials(t *testing.T) {
 
 	t.Log("putting the parentRefs back")
 	require.Eventually(t, func() bool {
-		httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name).Get(ctx, httpRoute.Name, metav1.GetOptions{})
+		httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns.Name).Get(ctx, httpRoute.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 		httpRoute.Spec.ParentRefs = oldParentRefs
-		httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name).Update(ctx, httpRoute, metav1.UpdateOptions{})
+		httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns.Name).Update(ctx, httpRoute, metav1.UpdateOptions{})
 		return err == nil
 	}, time.Minute, time.Second)
 
@@ -263,7 +263,7 @@ func TestHTTPRouteEssentials(t *testing.T) {
 	helpers.EventuallyGETPath(t, proxyURL, proxyURL.Host, "/test-http-route-essentials", http.StatusOK, "<title>httpbin.org</title>", emptyHeaderSet, ingressWait, waitTick)
 
 	t.Log("deleting the GatewayClass")
-	require.NoError(t, gatewayClient.GatewayV1beta1().GatewayClasses().Delete(ctx, gatewayClassName, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().GatewayClasses().Delete(ctx, gatewayClassName, metav1.DeleteOptions{}))
 
 	t.Log("verifying that the Gateway gets unlinked from the route via status")
 	callback = GetGatewayIsUnlinkedCallback(ctx, t, gatewayClient, gatewayapi.HTTPProtocolType, ns.Name, httpRoute.Name)
@@ -284,7 +284,7 @@ func TestHTTPRouteEssentials(t *testing.T) {
 	helpers.EventuallyGETPath(t, proxyURL, proxyURL.Host, "/test-http-route-essentials", http.StatusOK, "<title>httpbin.org</title>", emptyHeaderSet, ingressWait, waitTick)
 
 	t.Log("deleting the Gateway")
-	require.NoError(t, gatewayClient.GatewayV1beta1().Gateways(ns.Name).Delete(ctx, gatewayName, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().Gateways(ns.Name).Delete(ctx, gatewayName, metav1.DeleteOptions{}))
 
 	t.Log("verifying that the Gateway gets unlinked from the route via status")
 	callback = GetGatewayIsUnlinkedCallback(ctx, t, gatewayClient, gatewayapi.HTTPProtocolType, ns.Name, httpRoute.Name)
@@ -307,8 +307,8 @@ func TestHTTPRouteEssentials(t *testing.T) {
 	helpers.EventuallyGETPath(t, proxyURL, proxyURL.Host, "/test-http-route-essentials", http.StatusOK, "<title>httpbin.org</title>", emptyHeaderSet, ingressWait, waitTick)
 
 	t.Log("deleting both GatewayClass and Gateway rapidly")
-	require.NoError(t, gatewayClient.GatewayV1beta1().GatewayClasses().Delete(ctx, gwc.Name, metav1.DeleteOptions{}))
-	require.NoError(t, gatewayClient.GatewayV1beta1().Gateways(ns.Name).Delete(ctx, gateway.Name, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().GatewayClasses().Delete(ctx, gwc.Name, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().Gateways(ns.Name).Delete(ctx, gateway.Name, metav1.DeleteOptions{}))
 
 	t.Log("verifying that the Gateway gets unlinked from the route via status")
 	callback = GetGatewayIsUnlinkedCallback(ctx, t, gatewayClient, gatewayapi.HTTPProtocolType, ns.Name, httpRoute.Name)
@@ -329,11 +329,11 @@ func TestHTTPRouteEssentials(t *testing.T) {
 
 	// Set the Port in ParentRef which does not have a matching listener in Gateway.
 	require.Eventually(t, func() bool {
-		httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name).Get(ctx, httpRoute.Name, metav1.GetOptions{})
+		httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns.Name).Get(ctx, httpRoute.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 		port81 := gatewayapi.PortNumber(81)
 		httpRoute.Spec.ParentRefs[0].Port = &port81
-		httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name).Update(ctx, httpRoute, metav1.UpdateOptions{})
+		httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns.Name).Update(ctx, httpRoute, metav1.UpdateOptions{})
 		return err == nil
 	}, time.Minute, time.Second)
 
@@ -484,7 +484,7 @@ func TestHTTPRouteMultipleServices(t *testing.T) {
 			},
 		},
 	}
-	httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name).Create(ctx, httpRoute, metav1.CreateOptions{})
+	httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns.Name).Create(ctx, httpRoute, metav1.CreateOptions{})
 	require.NoError(t, err)
 	cleaner.Add(httpRoute)
 
@@ -596,7 +596,7 @@ func TestHTTPRouteFilterHosts(t *testing.T) {
 			}},
 		},
 	}
-	hClient := gatewayClient.GatewayV1beta1().HTTPRoutes(ns.Name)
+	hClient := gatewayClient.GatewayV1().HTTPRoutes(ns.Name)
 	httpRoute, err = hClient.Create(ctx, httpRoute, metav1.CreateOptions{})
 	require.NoError(t, err)
 	cleaner.Add(httpRoute)
diff --git a/test/integration/httproute_webhook_test.go b/test/integration/httproute_webhook_test.go
index 160510d8a..581d1be1f 100644
--- a/test/integration/httproute_webhook_test.go
+++ b/test/integration/httproute_webhook_test.go
@@ -270,7 +270,7 @@ func testHTTPRouteValidationWebhook(
 ) {
 	for _, tC := range testCases {
 		t.Run(tC.Name, func(t *testing.T) {
-			_, err := gatewayClient.GatewayV1beta1().HTTPRoutes(namespace).Create(ctx, tC.Route, metav1.CreateOptions{})
+			_, err := gatewayClient.GatewayV1().HTTPRoutes(namespace).Create(ctx, tC.Route, metav1.CreateOptions{})
 			if tC.WantCreateErrSubstring != "" {
 				require.Error(t, err)
 				require.Contains(t, err.Error(), tC.WantCreateErrSubstring)
diff --git a/test/integration/tcproute_test.go b/test/integration/tcproute_test.go
index 6f4f67d12..011998a13 100644
--- a/test/integration/tcproute_test.go
+++ b/test/integration/tcproute_test.go
@@ -238,7 +238,7 @@ func TestTCPRouteEssentials(t *testing.T) {
 	}, ingressWait, waitTick)
 
 	t.Log("deleting the Gateway")
-	require.NoError(t, gatewayClient.GatewayV1beta1().Gateways(ns.Name).Delete(ctx, gatewayName, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().Gateways(ns.Name).Delete(ctx, gatewayName, metav1.DeleteOptions{}))
 
 	t.Log("verifying that the Gateway gets unlinked from the route via status")
 	callback = GetGatewayIsUnlinkedCallback(ctx, t, gatewayClient, gatewayapi.TCPProtocolType, ns.Name, tcpRoute.Name)
@@ -271,8 +271,8 @@ func TestTCPRouteEssentials(t *testing.T) {
 	}, ingressWait, waitTick)
 
 	t.Log("deleting both GatewayClass and Gateway rapidly")
-	require.NoError(t, gatewayClient.GatewayV1beta1().GatewayClasses().Delete(ctx, gwc.Name, metav1.DeleteOptions{}))
-	require.NoError(t, gatewayClient.GatewayV1beta1().Gateways(ns.Name).Delete(ctx, gateway.Name, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().GatewayClasses().Delete(ctx, gwc.Name, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().Gateways(ns.Name).Delete(ctx, gateway.Name, metav1.DeleteOptions{}))
 
 	t.Log("verifying that the Gateway gets unlinked from the route via status")
 	callback = GetGatewayIsUnlinkedCallback(ctx, t, gatewayClient, gatewayapi.TCPProtocolType, ns.Name, tcpRoute.Name)
@@ -347,8 +347,8 @@ func TestTCPRouteEssentials(t *testing.T) {
 	}, ingressWait, waitTick)
 
 	t.Log("deleting both GatewayClass and Gateway rapidly")
-	require.NoError(t, gatewayClient.GatewayV1beta1().GatewayClasses().Delete(ctx, gwc.Name, metav1.DeleteOptions{}))
-	require.NoError(t, gatewayClient.GatewayV1beta1().Gateways(ns.Name).Delete(ctx, gateway.Name, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().GatewayClasses().Delete(ctx, gwc.Name, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().Gateways(ns.Name).Delete(ctx, gateway.Name, metav1.DeleteOptions{}))
 
 	t.Log("verifying that the Gateway gets unlinked from the route via status")
 	callback = GetGatewayIsUnlinkedCallback(ctx, t, gatewayClient, gatewayapi.TCPProtocolType, ns.Name, tcpRoute.Name)
diff --git a/test/integration/tlsroute_test.go b/test/integration/tlsroute_test.go
index 808e45044..3fb65d7c7 100644
--- a/test/integration/tlsroute_test.go
+++ b/test/integration/tlsroute_test.go
@@ -274,7 +274,7 @@ func TestTLSRoutePassthroughReferenceGrant(t *testing.T) {
 	}, ingressWait, waitTick)
 
 	t.Log("verifying that a Listener has the invalid ref status condition")
-	gateway, err = gatewayClient.GatewayV1beta1().Gateways(ns.Name).Get(ctx, gateway.Name, metav1.GetOptions{})
+	gateway, err = gatewayClient.GatewayV1().Gateways(ns.Name).Get(ctx, gateway.Name, metav1.GetOptions{})
 	require.NoError(t, err)
 	invalid := false
 	for _, status := range gateway.Status.Listeners {
@@ -496,7 +496,7 @@ func TestTLSRoutePassthrough(t *testing.T) {
 	}, ingressWait, waitTick)
 
 	t.Log("deleting the GatewayClass")
-	require.NoError(t, gatewayClient.GatewayV1beta1().GatewayClasses().Delete(ctx, gwc.Name, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().GatewayClasses().Delete(ctx, gwc.Name, metav1.DeleteOptions{}))
 
 	t.Log("verifying that the Gateway gets unlinked from the route via status")
 	callback = GetGatewayIsUnlinkedCallback(ctx, t, gatewayClient, gatewayapi.TLSProtocolType, ns.Name, tlsRoute.Name)
@@ -526,7 +526,7 @@ func TestTLSRoutePassthrough(t *testing.T) {
 	}, ingressWait, waitTick)
 
 	t.Log("deleting the Gateway")
-	require.NoError(t, gatewayClient.GatewayV1beta1().Gateways(ns.Name).Delete(ctx, gatewayName, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().Gateways(ns.Name).Delete(ctx, gatewayName, metav1.DeleteOptions{}))
 
 	t.Log("verifying that the Gateway gets unlinked from the route via status")
 	callback = GetGatewayIsUnlinkedCallback(ctx, t, gatewayClient, gatewayapi.TLSProtocolType, ns.Name, tlsRoute.Name)
@@ -615,8 +615,8 @@ func TestTLSRoutePassthrough(t *testing.T) {
 	}, ingressWait, waitTick)
 
 	t.Log("deleting both GatewayClass and Gateway rapidly")
-	require.NoError(t, gatewayClient.GatewayV1beta1().GatewayClasses().Delete(ctx, gwc.Name, metav1.DeleteOptions{}))
-	require.NoError(t, gatewayClient.GatewayV1beta1().Gateways(ns.Name).Delete(ctx, gateway.Name, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().GatewayClasses().Delete(ctx, gwc.Name, metav1.DeleteOptions{}))
+	require.NoError(t, gatewayClient.GatewayV1().Gateways(ns.Name).Delete(ctx, gateway.Name, metav1.DeleteOptions{}))
 
 	t.Log("verifying that the Gateway gets unlinked from the route via status")
 	callback = GetGatewayIsUnlinkedCallback(ctx, t, gatewayClient, gatewayapi.TLSProtocolType, ns.Name, tlsRoute.Name)
diff --git a/test/integration/translation_failures_test.go b/test/integration/translation_failures_test.go
index c4c1dec94..32e877dd0 100644
--- a/test/integration/translation_failures_test.go
+++ b/test/integration/translation_failures_test.go
@@ -122,7 +122,7 @@ func TestTranslationFailures(t *testing.T) {
 				cleaner.Add(service2)
 
 				httpRoute := httpRouteWithBackends(gatewayName, service1, service2)
-				httpRoute, err = gatewayClient.GatewayV1beta1().HTTPRoutes(ns).Create(ctx, httpRoute, metav1.CreateOptions{})
+				httpRoute, err = gatewayClient.GatewayV1().HTTPRoutes(ns).Create(ctx, httpRoute, metav1.CreateOptions{})
 				require.NoError(t, err)
 				cleaner.Add(httpRoute)
 
diff --git a/test/integration/udproute_test.go b/test/integration/udproute_test.go
index 6f3c51893..34b4093df 100644
--- a/test/integration/udproute_test.go
+++ b/test/integration/udproute_test.go
@@ -252,7 +252,7 @@ func TestUDPRouteEssentials(t *testing.T) {
 
 	t.Run("removing GatewayClass", func(t *testing.T) {
 		t.Log("deleting the GatewayClass")
-		require.NoError(t, gatewayClient.GatewayV1beta1().GatewayClasses().Delete(ctx, gatewayClassName, metav1.DeleteOptions{}))
+		require.NoError(t, gatewayClient.GatewayV1().GatewayClasses().Delete(ctx, gatewayClassName, metav1.DeleteOptions{}))
 
 		t.Log("verifying that the Gateway gets unlinked from the route via status")
 		callback = GetGatewayIsUnlinkedCallback(ctx, t, gatewayClient, gatewayapi.UDPProtocolType, ns.Name, udpRoute.Name)
@@ -282,7 +282,7 @@ func TestUDPRouteEssentials(t *testing.T) {
 
 	t.Run("removing Gateway", func(t *testing.T) {
 		t.Log("deleting the Gateway")
-		require.NoError(t, gatewayClient.GatewayV1beta1().Gateways(ns.Name).Delete(ctx, gatewayName, metav1.DeleteOptions{}))
+		require.NoError(t, gatewayClient.GatewayV1().Gateways(ns.Name).Delete(ctx, gatewayName, metav1.DeleteOptions{}))
 
 		t.Log("verifying that the Gateway gets unlinked from the route via status")
 		callback = GetGatewayIsUnlinkedCallback(ctx, t, gatewayClient, gatewayapi.UDPProtocolType, ns.Name, udpRoute.Name)
@@ -318,8 +318,8 @@ func TestUDPRouteEssentials(t *testing.T) {
 
 	t.Run("removing Gateway and GatewayClass simultaneously", func(t *testing.T) {
 		t.Log("deleting both GatewayClass and Gateway")
-		require.NoError(t, gatewayClient.GatewayV1beta1().GatewayClasses().Delete(ctx, gatewayClassName, metav1.DeleteOptions{}))
-		require.NoError(t, gatewayClient.GatewayV1beta1().Gateways(ns.Name).Delete(ctx, gatewayName, metav1.DeleteOptions{}))
+		require.NoError(t, gatewayClient.GatewayV1().GatewayClasses().Delete(ctx, gatewayClassName, metav1.DeleteOptions{}))
+		require.NoError(t, gatewayClient.GatewayV1().Gateways(ns.Name).Delete(ctx, gatewayName, metav1.DeleteOptions{}))
 
 		t.Log("verifying that the Gateway gets unlinked from the route via status")
 		callback = GetGatewayIsUnlinkedCallback(ctx, t, gatewayClient, gatewayapi.UDPProtocolType, ns.Name, udpRoute.Name)