Containers

Migrate GKE Ingress to Gateway API with Certificate Manager

Moving GKE Ingress to Gateway API is safe only if you build the new load balancer first, get its certificate active, and flip DNS last. We ran the migration both ways: reusing the Ingress IP cost about 8 minutes of failed HTTPS, while a new Gateway IP plus a 60-second DNS TTL moved 356 probe requests across with zero connection failures and 5 transient 404s.

Original content from computingforgeeks.com - post 166188

This guide moves two services from per-service Ingress and ManagedCertificate to one Gateway with HTTPRoutes and a Certificate Manager cert map. You’ll see the real kubectl get gateway and httproute status, the cert map output, curl -vI against the new load balancer, every error we hit during the cutover, and the measured cert provisioning and DNS cutover times. Every command below was run on a GKE Autopilot 1.36 cluster in europe-west1 in November 2026.

Follow the GKE Ingress to Gateway API cutover order

We run the old and new paths side by side. Each Ingress keeps its own load balancer and IP until the end, while the Gateway gets a fresh global external Application Load Balancer whose TLS comes from a Certificate Manager cert map instead of a Kubernetes object. DNS is the only switch, so you can test the new path for as long as you like and roll back by changing one record. The order you follow matters more than any single manifest.

  1. Reserve a new static IP for the Gateway
  2. Create the Certificate Manager certificate and cert map
  3. Deploy the Gateway and HTTPRoutes beside the Ingresses
  4. Probe the Gateway IP until it runs clean
  5. Flip DNS, then delete each Ingress

Steps 1 to 4 touch nothing your users hit, so you can stop at any of them. The diagram shows both paths during that overlap.

Architecture diagram: clients resolve the DNS A record to the old Ingress load balancers before cutover and to the global external ALB after; Certificate Manager serves TLS by SNI and the GKE Gateway programs the ALB, which sends HTTP to pods via NEG

We’re at part five of the GCP certificate consolidation series here. The ManagedCertificate sprawl audit explains why one cert per service gets expensive, and the shared load balancer cert map swap did the same consolidation for non-GKE backends. Here the GKE workloads join that model.

Check Gateway API on the GKE cluster

GKE installs and manages the Gateway API CRDs itself, so there is nothing to kubectl apply from GitHub, and every step below can use GCP’s own tooling (gcloud, kubectl and the GKE auth plugin). You only need to confirm the controller is on and that the GatewayClass you want exists. The lab used these versions.

  • GKE Autopilot on the Regular channel, control plane 1.36.4
  • Gateway API bundle v1.6.0, standard channel, installed by GKE
  • kubectl and gke-gcloud-auth-plugin from the Google Cloud apt repo on an Ubuntu 26.04 VM

Set the two values every command reuses. Change them to your own cluster name and region.

export CLUSTER=shop-gke
export REGION=europe-west1

Then read the Gateway API channel. On current gcloud it lives under networkConfig, not addonsConfig where older guides (including the first version of this one) looked, and that older path now prints an empty value.

gcloud container clusters describe ${CLUSTER} --region ${REGION} \
  --format="yaml(networkConfig.gatewayApiConfig)"
kubectl get gatewayclass

You want CHANNEL_STANDARD and four gke-l7-* classes owned by networking.gke.io/gateway.

kubectl get gatewayclass on GKE 1.36 showing gke-l7-global-external-managed and the Gateway API standard channel

On a brand new Autopilot cluster, kubectl get gatewayclass printed No resources found for the first minutes after create-auto returned, so do not treat an empty list as a missing feature until the cluster has settled. Autopilot always runs the GKE Gateway controller; on a Standard cluster with an empty channel, turn it on with gcloud container clusters update and its --gateway-api=standard flag.

This guide uses gke-l7-global-external-managed, the current global external Application Load Balancer. GKE Ingress builds the classic load balancer, whose Gateway equivalent is gke-l7-gxlb, so this migration is also an upgrade of the load balancer generation. The six gke-persistent-* and gke-passthrough-* classes belong to a different controller for L4 and persistent IPs and do not apply here. The regional vs global external ALB comparison covers when gke-l7-regional-external-managed is the better pick.

Review the Ingress starting point

The starting point is the classic GKE sprawl: each Service has its own Ingress, its own reserved global IP and its own ManagedCertificate. Two Deployments (food-web and admin-web, Google’s hello-app image on port 8080) sat behind ClusterIP Services annotated cloud.google.com/neg: '{"ingress": true}'. The food Ingress looked like this.

apiVersion: networking.gke.io/v1
kind: ManagedCertificate
metadata:
  name: food-cert
  namespace: shop
spec:
  domains: [food.203-0-113-21.sslip.io]
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: food-web
  namespace: shop
  annotations:
    kubernetes.io/ingress.class: gce
    kubernetes.io/ingress.global-static-ip-name: food-ing-ip
    networking.gke.io/managed-certificates: food-cert
spec:
  defaultBackend:
    service: {name: food-web, port: {number: 80}}
  rules:
  - host: food.203-0-113-21.sslip.io
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service: {name: food-web, port: {number: 80}}

The hostnames use sslip.io, a public wildcard DNS service where food.203-0-113-21.sslip.io resolves to 203.0.113.21. That let Google issue real publicly trusted certificates in the lab without a delegated zone. With your own domain, the names are simply yours. Applying the manifest also printed Warning: annotation "kubernetes.io/ingress.class" is deprecated. The capture below shows the state about two and a half minutes after apply, and again at 14 minutes.

GKE Ingress and ManagedCertificate before migration, two load balancer IPs and food-cert stuck in Provisioning

You’re paying for two IPs and four global forwarding rules (one HTTP, one HTTPS per Ingress) to serve two services. The admin-cert object went Active eight minutes after apply. food-cert still read Provisioning at 14 minutes even though curl already got HTTP/2 200 with a valid Google Trust Services certificate from 9 minutes 15 seconds onwards. The ManagedCertificate status lags the load balancer, so test with curl before you sit and wait on it.

Create the Gateway IP and certificate first

Give the Gateway a new static IP rather than taking over an Ingress IP, even though reusing the IP looks like it saves you a DNS change. We tried the takeover first, pointing the Gateway at the food Ingress address, and GKE refused it while the Ingress held the address (that run named it food-ip rather than food-ing-ip).

LAST SEEN   TYPE      REASON   OBJECT            MESSAGE
50s         Warning   SYNC     gateway/shop-gw   error ensuring load balancer: client.Insert(, gkegw1-ns1w-shop-shop-gw-3lty5qmrhza2): generic::invalid_argument: Invalid value for field 'request.resource.IPAddress': 'global/addresses/food-ip'. Specified IP address is in-use and would result in a conflict.; client.Insert(, gkegw1-ns1w-shop-shop-gw-xfj02o7cfm56): generic::invalid_argument: Invalid value for field 'request.resource.IPAddress': 'global/addresses/food-ip'. Specified IP address is in-use and would result in a conflict.

Keeping the IP means deleting the Ingress first, and that run measured about 8 minutes of failed HTTPS (09:49:22 to the first 200 at 09:57:29 UTC), followed by flapping between 200 and connection failures while the new load balancer spread to Google’s edge. A separate IP costs you one more address for the length of the overlap and removes that outage. The old version of this guide also hit Quota 'IN_USE_ADDRESSES' exceeded. Limit: 4.0 globally. Our lab project showed a global limit of 8, and you can check yours before you start.

gcloud compute project-info describe --flatten=quotas \
  --format="table(quotas.metric,quotas.limit,quotas.usage)" | grep -E "IN_USE_ADDRESSES|STATIC_ADDRESSES"

Reserve the address and read it back into two variables, one dotted and one dashed for the sslip.io names. gcloud compute addresses create --global rejects --labels with unrecognized arguments, so labels go on in a second call.

gcloud compute addresses create shop-gw-ip --global
gcloud compute addresses update shop-gw-ip --global --update-labels=app=shop
export GW_IP=$(gcloud compute addresses describe shop-gw-ip --global --format="value(address)")
export GW_DASH=${GW_IP//./-}
echo ${GW_IP} ${GW_DASH}

Next comes the Google-managed certificate, and the authorization type decides whether your cutover is clean. Pick it by where your hostnames point today:

  • Names already live on the Ingress: DNS authorization (one CNAME per domain)
  • New names that point at the Gateway IP from day one: load balancer authorization

Load balancer authorization only completes once the hostname resolves to a load balancer serving this cert map. For a name that still resolves to the Ingress, that means after the DNS flip, so HTTPS on the new path fails until Google issues the certificate. Google’s domain authorization page recommends DNS authorization for migrations for exactly that reason, and a DNS-authorized certificate is ACTIVE before the Gateway even exists. Create that one with the steps in the wildcard certificate with DNS authorization guide; the map and entry commands below stay the same. This lab used load balancer authorization because sslip.io names embed the Gateway IP, so they pointed at the Gateway from the start:

gcloud certificate-manager certificates create shop-gw-cert \
  --domains="food.${GW_DASH}.sslip.io,admin.${GW_DASH}.sslip.io"
gcloud certificate-manager maps create shop-cert-map-r2
gcloud certificate-manager maps entries create food-entry-r2 --map shop-cert-map-r2 \
  --hostname "food.${GW_DASH}.sslip.io" --certificates shop-gw-cert
gcloud certificate-manager maps entries create admin-entry-r2 --map shop-cert-map-r2 \
  --hostname "admin.${GW_DASH}.sslip.io" --certificates shop-gw-cert

The -r2 suffix is there because an earlier run in the same project still owned shop-cert-map, and maps create returned ALREADY_EXISTS. Right after creation the certificate is PROVISIONING and both entries are PENDING.

Certificate Manager certificate in PROVISIONING with AUTHORIZING domains and PENDING cert map entries

How long that lasts depends on where the name points. In the IP takeover run, the certificate was created while the Ingress still owned the address its hostnames resolved to, and it took 38 minutes from create (09:09:07 UTC) to AUTHORIZED (09:47:37). The attempt log explained the wait. A second certificate created later that day, for names Google had already authorized, showed both domains AUTHORIZED four seconds after create. If your hostname is new to Google, plan for the slow case.

Error: “RESOLVED_TO_NOT_SERVING” and “CERTIFICATE_NOT_ATTACHED”

While the hostname still resolved to the Ingress load balancer, gcloud certificate-manager certificates describe showed every attempt failing with these two issues.

  - attemptTime: '2026-11-11T09:09:14.099804806Z'
    domain: food.203-0-113-21.sslip.io
    failureReason: CONFIG
    state: FAILED
    troubleshooting:
      ips:
        resolved:
        - 203.0.113.21
      issues:
      - RESOLVED_TO_NOT_SERVING
      - CERTIFICATE_NOT_ATTACHED
  provisioningIssue:
    reason: AUTHORIZATION_ISSUE
  state: PROVISIONING

The two issues say what Google’s validator saw: the name resolved to a load balancer that was not serving this certificate. You don’t need to recreate anything, because Certificate Manager keeps retrying on its own. In our run the attempts flipped to AUTHORIZED at 09:47:37, around the time the Ingress was being removed, so the lab can’t pin the exact trigger. What it does show is the risk for a real migration: with load balancer authorization, a name still served by the Ingress has no usable certificate on the Gateway, which is why DNS authorization is the path for live hostnames.

Deploy the Gateway with the certmap annotation

One Gateway replaces every Ingress you had. It references the reserved IP by name, takes TLS from the cert map annotation and keeps an HTTP listener on port 80 for plain-HTTP clients. Create the manifest.

vim gateway.yaml

Add the Gateway. The HTTPS listener has no tls block because the annotation supplies the certificates.

apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: shop-gw
  namespace: shop
  annotations:
    networking.gke.io/certmap: shop-cert-map-r2
spec:
  gatewayClassName: gke-l7-global-external-managed
  addresses:
  - type: NamedAddress
    value: shop-gw-ip
  listeners:
  - name: https
    protocol: HTTPS
    port: 443
  - name: http
    protocol: HTTP
    port: 80

The first version of this guide carried tls: {mode: Terminate, options: {networking.gke.io/pre-shared-certs: ""}} on the HTTPS listener. We applied that form again on GKE 1.36, and it was accepted and went PROGRAMMED without an error, but Google’s Secure a Gateway page shows the certmap Gateway with no tls section, and a certificateRefs entry next to the annotation is treated as an error. Use the documented form above so you aren’t relying on behavior Google doesn’t describe. Apply it.

kubectl apply -f gateway.yaml

On the first create, from apply to PROGRAMMED=True with the address populated took 3 minutes 26 seconds (we measured it on the earlier tls.options form, then updated the same Gateway in place to the manifest above). During that time kubectl describe gateway shop-gw -n shop shows Accepted first and a growing list of networking.gke.io/* annotations (forwarding rules, target proxies, URL maps) as the controller builds the load balancer. The Ready condition carries a message that it is deprecated in favour of Programmed, so your scripts should wait on Programmed.

Add HTTPRoutes for each service

Each service gets an HTTPRoute that names the Gateway in parentRefs and lists the hostnames it answers for. The routes point at the same Services the Ingresses used, so you don’t touch a single Deployment. Open the routes file.

vim httproutes.yaml

Add both routes. The extra food.shop.internal hostname exists only for the DNS cutover test later; you can leave it out in your own setup. Replace 203-0-113-10 with your own ${GW_DASH} value, or with your real hostnames.

apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: food-web
  namespace: shop
spec:
  parentRefs:
  - name: shop-gw
  hostnames: ["food.203-0-113-10.sslip.io", "food.shop.internal"]
  rules:
  - backendRefs:
    - name: food-web
      port: 80
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: admin-web
  namespace: shop
spec:
  parentRefs:
  - name: shop-gw
  hostnames: ["admin.203-0-113-10.sslip.io"]
  rules:
  - backendRefs:
    - name: admin-web
      port: 80

Apply the routes and check the Gateway and route status together.

kubectl apply -f httproutes.yaml
kubectl get gateway,httproute -n shop -o wide
gcloud compute forwarding-rules list --global

The Gateway owns 203.0.113.10 with its own two forwarding rules, while the four k8s2-* Ingress rules on .21 and .22 keep serving the old path.

kubectl get gateway httproute showing shop-gw PROGRAMMED True next to the old Ingress forwarding rules

Route status lives under status.parents, one entry per Gateway. Accepted means the Gateway took the route, ResolvedRefs means every backend exists and may be referenced, and GKE adds Reconciled once the load balancer config is pushed.

kubectl get httproute food-web -n shop -o jsonpath='{.status.parents[0].conditions}'

All three came back True. Accepted and ResolvedRefs arrived 10 seconds after apply, Reconciled 2 minutes 50 seconds after.

[{"lastTransitionTime":"2026-11-11T13:00:31Z","message":"","observedGeneration":1,"reason":"ResolvedRefs","status":"True","type":"ResolvedRefs"},{"lastTransitionTime":"2026-11-11T13:00:31Z","message":"","observedGeneration":1,"reason":"Accepted","status":"True","type":"Accepted"},{"lastTransitionTime":"2026-11-11T13:03:11Z","message":"","observedGeneration":1,"reason":"ReconciliationSucceeded","status":"True","type":"Reconciled"}]

Green conditions don’t mean the Gateway is serving your traffic yet. A probe hitting the Gateway IP once a second from the moment the routes were applied tells the real story.

Event (routes applied at 13:00:21 UTC)TimeAfter apply
HTTPRoutes Accepted, ResolvedRefs13:00:3110 s
HTTPRoute Reconciled13:03:112 min 50 s
First HTTP 200 through the Gateway IP13:05:285 min 7 s
Last 404 seen on the Gateway13:11:2711 min 6 s

Before the first 200, the probe logged 259 responses of 404, 38 of 502 and 8 connection failures, 7 of them in the seconds before the routes landed. The 404s came from the controller’s serve404 default backend and the 502s from backends whose NEG health checks hadn’t passed yet. After it, 10 of the next 508 requests still got a 404 or 502 over four minutes, and the cutover probe below saw its last 404 at 13:11:27, while the new URL map reached every Google front end. The working rule from this lab is to wait 15 minutes after the routes go Reconciled, and watch a probe run clean, before you move any DNS.

Verify the cert map and Gateway TLS

Once the Gateway is programmed, the cert map records which target proxy uses it, and both entries flip from PENDING to ACTIVE. Check the map, the entries and the certificate a client actually receives.

gcloud certificate-manager maps describe shop-cert-map-r2
gcloud certificate-manager maps entries list --map shop-cert-map-r2
curl -vI https://food.${GW_DASH}.sslip.io/

The gclbTargets block names the Gateway’s gkegw1-* HTTPS proxy on 203.0.113.10:443, and curl shows TLS 1.3 with a Google Trust Services WR3 certificate whose SAN matches the hostname.

gcloud certificate-manager maps describe with gclbTargets and curl -vI showing the Google Trust Services certificate on the Gateway

We trimmed the capture to the TLS and status lines. The admin hostname returned the same certificate (subject CN=food..., SAN list covering admin), because one Certificate Manager certificate carries both names and the map hands it out by SNI. No Kubernetes Secret, no ManagedCertificate, and the cluster never sees a private key.

Switch DNS without dropping connections

With both paths serving, your cutover is one DNS change. Lower the record TTL a day ahead so resolvers drop the old answer quickly, then point the name at the Gateway IP. To measure it, we used a Cloud DNS private zone (shop.internal, TTL 60) and a probe on a VM in the same VPC. With a public zone for your own domain you can skip the zone and work on your existing record. The lab zone and its starting record pointed at the food Ingress:

gcloud dns managed-zones create shop-internal --dns-name=shop.internal. \
  --visibility=private --networks=default --description="shop private zone"
gcloud dns record-sets create food.shop.internal. --zone=shop-internal \
  --type=A --ttl=60 --rrdatas=203.0.113.21

From a VM in the same VPC, start the probe. It logs the time, the status code and the IP it reached once a second.

while true; do echo "$(date +%T) $(curl -s -o /dev/null -w '%{http_code} %{remote_ip}' --max-time 3 http://food.shop.internal/)"; sleep 1; done | tee cutover.log

In a second terminal, update the record to the Gateway IP. For a public Cloud DNS zone the command is the same with your own zone and record name.

gcloud dns record-sets update food.shop.internal. --zone=shop-internal \
  --type=A --ttl=60 --rrdatas=${GW_IP}

The record changed at 13:08:20 and the probe reached the Gateway from 13:08:50, 30 seconds later. Counting the whole log by status and IP gives the cutover result.

DNS cutover probe moving from the Ingress IP to the Gateway IP with 351 200 responses and 5 404s

That is 356 requests over six minutes, zero timeouts and zero connection failures. The five 404s all came from the Gateway, at 13:08:56, 13:10:02, 13:10:33, 13:11:16 and 13:11:27, which lines up with the propagation tail in the table above: we flipped DNS only three minutes after the first 200. If you wait the full 15 minutes, you shouldn’t see them at all. The probe was plain HTTP, so it measures the load balancer and DNS switch, not TLS. Before you flip a real hostname, confirm HTTPS on the Gateway by pinning the name to the Gateway IP with curl’s --resolve option, which only succeeds once the certificate is ACTIVE. Compare all of that with the IP takeover run, where HTTPS failed for about 8 minutes straight.

Delete the old Ingress and its certificate once no client still resolves the old IP (give it a few TTLs, longer for public names with resolvers that ignore TTLs). The delete took 76 seconds to return, and the Ingress IP can then be released.

kubectl delete ingress food-web -n shop
kubectl delete managedcertificate food-cert -n shop
gcloud compute addresses delete food-ing-ip --global

Repeat the record change and cleanup for each hostname you have left. During the overlap the old Ingress has its own failure mode, covered next.

Error: “Translation failed: invalid ingress spec: service is type ClusterIP”

Once the HTTPRoutes existed, the Gateway controller rewrote the Services’ NEG annotation from {"ingress": true} to {"exposed_ports":{"80":{}}}. From then on both Ingresses logged this warning every few minutes.

shop              16m         Warning   Translate                                ingress/food-web                                               Translation failed: invalid ingress spec: service "shop/food-web" is type "ClusterIP", expected "NodePort" or "LoadBalancer" when not using NEGs; service "shop/food-web" is type "ClusterIP", expected "NodePort" or "LoadBalancer" when not using NEGs

The existing Ingress load balancer kept answering 200 throughout, because GCE resources already built are left alone. What breaks is any change: an edit to an Ingress during the overlap won’t reach its load balancer. Freeze Ingress changes from the moment you apply the routes, and keep the overlap short. If you must change routing during that window, change the HTTPRoute.

Allow cross-namespace routes with ReferenceGrant

An HTTPRoute can send traffic to a Service in another namespace, which Ingress can’t, but only when the target namespace allows it with a ReferenceGrant. GKE 1.36 serves ReferenceGrant at v1 as well as v1beta1, so the old v1beta1 manifests still apply. To test it, a billing-api Service in namespace billing got a route in namespace shop.

apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: billing
  namespace: shop
spec:
  parentRefs:
  - name: shop-gw
  hostnames: ["admin.203-0-113-10.sslip.io"]
  rules:
  - matches:
    - path: {type: PathPrefix, value: /billing}
    backendRefs:
    - name: billing-api
      namespace: billing
      port: 80

Without a grant the route is accepted but its backend isn’t resolved, and the request path fails in a way that’s easy to misread.

Error: “GWCER104: no valid reference grant found” and “fault filter abort”

The route status reported ResolvedRefs False with reason RefNotPermitted and the message Error GWCER104: HTTPRoute "shop/billing" is misconfigured, err: no valid reference grant found for Backend billing/billing-api to be referenced. The client side showed something else: /billing returned 200 from the admin-web pod, because the admin route still matched / and the broken route was not in the load balancer yet. Nothing in the response tells you the route is dead, so read the route status rather than trusting curl. Create the grant in the target namespace.

vim referencegrant.yaml

It allows HTTPRoutes from shop to reference Services in billing, nothing more.

apiVersion: gateway.networking.k8s.io/v1
kind: ReferenceGrant
metadata:
  name: allow-shop-routes
  namespace: billing
spec:
  from:
  - group: gateway.networking.k8s.io
    kind: HTTPRoute
    namespace: shop
  to:
  - group: ""
    kind: Service

Apply it, then watch the route condition and the endpoint.

kubectl apply -f referencegrant.yaml
kubectl get httproute billing -n shop -o jsonpath='{.status.parents[0].conditions}'
curl -s -w ' %{http_code}\n' https://admin.${GW_DASH}.sslip.io/billing

The lab capture shows the route before and after the grant.

HTTPRoute RefNotPermitted GWCER104 status, fault filter abort 500 after the ReferenceGrant while GKE reconciles, then 200 from billing-api

The grant does not fix things instantly. From 13:17:26, while the status still read RefNotPermitted, most requests to /billing got fault filter abort with HTTP 500, the response the Gateway API spec requires for a route whose backend is invalid. The condition turned True 2 minutes 37 seconds after the grant was created, but /billing kept returning the 500 until 5 minutes 44 seconds, when the billing-api pod answered. When you see that body on a GKE Gateway, it’s the load balancer refusing an unresolved backend, not your application failing. Budget that gap into any change window where you add a cross-namespace route. The platform team owns the Gateway, the app team owns the route, and the grant is the only object the backend team has to approve.

Keep a rollback path, then clean up

Rollback is the cutover in reverse, and you only get it while the Ingress still exists. Point the A record back at the Ingress IP and clients return within one TTL (60 seconds here; the forward switch took 30). We didn’t run the reverse flip in the lab, but it is the same record change.

That’s the reason to keep each Ingress until its hostname has run clean on the Gateway for a day, and to keep the Ingress and ManagedCertificate manifests in Git rather than only in the cluster. After the Ingress is deleted, rolling back means rebuilding it and waiting on a new ManagedCertificate, which took 8 minutes for one service and more than 14 for the other in this lab. Before you delete it, put the new hostname under the certificate expiry alerts and rotation runbooks, because an uptime check reads the certificate the Gateway actually serves and catches a map entry still pointing at the wrong one.

To tear the lab down, delete the Kubernetes objects before the cluster so the controllers remove their load balancers, then the Certificate Manager objects in dependency order (entries, map, certificate), the addresses and the private DNS zone.

kubectl delete httproute --all -n shop
kubectl delete gateway shop-gw -n shop
kubectl delete ingress admin-web -n shop
kubectl delete managedcertificate admin-cert -n shop
kubectl delete namespace billing
gcloud container clusters delete ${CLUSTER} --region ${REGION} --quiet
gcloud certificate-manager maps entries delete food-entry-r2 --map shop-cert-map-r2 --quiet
gcloud certificate-manager maps entries delete admin-entry-r2 --map shop-cert-map-r2 --quiet
gcloud certificate-manager maps delete shop-cert-map-r2 --quiet
gcloud certificate-manager certificates delete shop-gw-cert --quiet
gcloud compute addresses delete shop-gw-ip --global --quiet
gcloud compute addresses delete admin-ing-ip --global --quiet
gcloud dns record-sets delete food.shop.internal. --zone=shop-internal --type=A
gcloud dns managed-zones delete shop-internal --quiet

GKE can leave load balancer parts behind after a cluster delete, so check these lists come back empty before you call the project clean.

  • gcloud compute network-endpoint-groups list
  • gcloud compute health-checks list
  • gcloud compute forwarding-rules list --global
  • gcloud certificate-manager maps list

Your Gateway resources move to a regional load balancer by changing gatewayClassName, which is where the next article in the series picks up. If you’re coming from ingress-nginx rather than GKE’s own Ingress, the ingress-nginx to Gateway API migration covers the annotation translation that GKE users don’t need.

Keep reading

Best UI Applications for Managing Docker Containers Containers Best UI Applications for Managing Docker Containers Install Docker and Run Containers on Ubuntu 24.04|22.04 Containers Install Docker and Run Containers on Ubuntu 24.04|22.04 Install UniFi OS Server on Ubuntu 24.04 LTS Containers Install UniFi OS Server on Ubuntu 24.04 LTS OpenCloud vs ownCloud vs Nextcloud: Tested on Identical VMs Cloud OpenCloud vs ownCloud vs Nextcloud: Tested on Identical VMs Kiri Container Runtime on Linux: Install and Benchmark vs Docker Containers Kiri Container Runtime on Linux: Install and Benchmark vs Docker How To Install Kubernetes Dashboard using Helm Kubernetes How To Install Kubernetes Dashboard using Helm

Leave a Comment

Press ESC to close