ListenerSet Has Landed on Application Gateway for Containers

About a year ago I wrote about why Gateway API multi-tenancy felt awkward and why we migrated anyway. The short version: TLS certificates live on the Gateway, so in a multi-tenant cluster every customer’s hostname ends up as a listener in one central resource. The fix was going to be ListenerSet, but it was experimental, cert-manager didn’t support it, and neither did Azure Application Gateway for Containers (AGC).

I ended that post hoping it would “feel like a historical curiosity” within a year. That turned out to be roughly right. As of the latest Helm release, the ALB Controller for AGC supports ListenerSet.

⚠
Not tested yet
We haven’t run this yet. Everything below comes from the Gateway API spec, the cert-manager docs, and Microsoft’s documentation and release notes. Think of this as a plan and a reading guide, not a field report. I’ll write a follow-up once we’ve run it on a real cluster.

What Changed Since Last Year

Three things had to happen, and all three did:

PieceLast yearNow
Gateway APIXListenerSet, experimental v1.3.0ListenerSet is GA, Standard channel since v1.5.0
cert-managerSupport planned for early 2026Alpha support in 1.20 (March 2026), HTTP-01 improvements in 1.21 (July 2026)
AGCNo ListenerSet supportALB Controller 1.13.0 supports ListenerSet and Gateway API v1.6.2

Gateway API: ListenerSet is v1

ListenerSet graduated to the Standard channel in Gateway API v1.5, alongside TLSRoute and a few other long-requested features. The resource is now gateway.networking.k8s.io/v1, kind ListenerSet. The x-k8s.io group and the X prefix from last year’s examples are gone.

The semantics are what the GEP promised. A Gateway accepts no ListenerSets by default. The Gateway owner opts in through spec.allowedListeners, and each ListenerSet points back at its parent Gateway with spec.parentRef.

cert-manager: alpha, behind a feature gate

cert-manager 1.20 added ListenerSet support. It’s still marked alpha, and you have to enable it explicitly. You use the same annotations as on a Gateway (cert-manager.io/cluster-issuer and friends), but now on the ListenerSet, so cert-manager creates the Certificate in the app’s namespace.

cert-manager 1.21 added the piece that matters most for our setup: the acme.cert-manager.io/http01-parentreffallback annotation. Without it, an HTTP-01 challenge for a ListenerSet needs an HTTP listener on that ListenerSet. With it, cert-manager attaches the solver route to the parent Gateway instead. One shared port 80 listener on the Gateway then serves ACME challenges for every tenant, and the ListenerSets can be HTTPS-only.

AGC: ALB Controller 1.13.0

The ALB Controller release notes list ListenerSet as a new feature in 1.13.0, together with a jump to Gateway API v1.6.2. Two details are easy to miss:

  • Helm only, for now. The AKS add-on pins the ALB Controller to the AKS version: v1.10.x up to AKS 1.35 and v1.11.x from 1.36. Neither has ListenerSet. If you use the add-on, you either switch to the Helm chart or wait for the add-on to catch up.
  • Kubernetes 1.32 minimum. The 1.12.x line already raised it from 1.27, but check this if you’re skipping releases.

Microsoft also published a concept page on the multi-team shared gateway operating model. It’s worth reading in full. It’s refreshingly clear about what ListenerSet does and does not give you, and I’ll come back to that below.

Where We Are Today

We went with what I called “Option 2” last year: migrate to AGC now, put every listener on the central Gateway, refactor later. That’s what we’re running.

It works, and AGC fixed the problems that made us leave the Application Gateway Ingress Controller (AGIC). But the Gateway is exactly the growing list I predicted. Every new customer domain means a change to a shared resource that touches every other customer’s traffic. The certificates live in the Gateway’s namespace instead of next to the apps they belong to.

“Later” is now.

The Target Setup

Here is how I expect the pieces to fit together on AGC, based on Microsoft’s how-to and the cert-manager ListenerSet docs.

cert-manager

Turn on Gateway API support, ListenerSet reconciliation, and the feature gate:

1# cert-manager values.yaml
2config:
3  gatewayAPI:
4    enabled: true
5    enableListenerSet: true
6  featureGates:
7    ListenerSets: true

cert-manager 1.21 renamed the config fields. If you still have enableGatewayAPI from an older setup, it keeps working, but it’s deprecated.

The Gateway (platform-owned)

The Gateway shrinks to the infrastructure boundary: which AGC it binds to, which namespaces may attach listeners, and a shared HTTP listener.

 1apiVersion: gateway.networking.k8s.io/v1
 2kind: Gateway
 3metadata:
 4  name: main-gateway
 5  namespace: gateway-system
 6  annotations:
 7    alb.networking.azure.io/alb-namespace: alb-infra
 8    alb.networking.azure.io/alb-name: alb-main
 9spec:
10  gatewayClassName: azure-alb-external
11  allowedListeners:
12    namespaces:
13      from: Selector
14      selector:
15        matchLabels:
16          gateway-access: "true"
17  listeners:
18    # Shared port 80 listener: serves ACME HTTP-01 challenges for every
19    # tenant (via cert-manager's parentRef fallback) and HTTP->HTTPS redirects.
20    - name: http
21      port: 80
22      protocol: HTTP
23      allowedRoutes:
24        namespaces:
25          from: Selector
26          selector:
27            matchLabels:
28              gateway-access: "true"

This example uses the ALB-managed deployment. With bring-your-own, you set the alb.networking.azure.io/alb-id annotation and an addresses entry for the frontend instead. Microsoft’s how-to shows both.

Notice that listeners is not empty. More on that in the corrections below.

The ListenerSet (per customer)

Each customer namespace gets one ListenerSet with its HTTPS listener and its certificate:

 1apiVersion: gateway.networking.k8s.io/v1
 2kind: ListenerSet
 3metadata:
 4  name: customer-a
 5  namespace: customer-a
 6  annotations:
 7    cert-manager.io/cluster-issuer: letsencrypt-prod
 8    acme.cert-manager.io/http01-parentreffallback: "true"
 9spec:
10  parentRef:
11    group: gateway.networking.k8s.io
12    kind: Gateway
13    name: main-gateway
14    namespace: gateway-system
15  listeners:
16    - name: https
17      hostname: app.customer-a.com
18      port: 443
19      protocol: HTTPS
20      tls:
21        mode: Terminate
22        certificateRefs:
23          - name: customer-a-tls
24      allowedRoutes:
25        namespaces:
26          from: Same

The certificate Secret lives in customer-a, the same namespace as the ListenerSet, so no ReferenceGrant is needed.

The HTTPRoute (per customer)

The route now targets the ListenerSet instead of the Gateway:

 1apiVersion: gateway.networking.k8s.io/v1
 2kind: HTTPRoute
 3metadata:
 4  name: app
 5  namespace: customer-a
 6spec:
 7  parentRefs:
 8    - group: gateway.networking.k8s.io
 9      kind: ListenerSet
10      name: customer-a
11      sectionName: https
12  hostnames:
13    - app.customer-a.com
14  rules:
15    - backendRefs:
16        - name: app
17          port: 80

That’s exactly the split last year’s post was hoping for:

ResourceOwnerConcerns
GatewayPlatformAGC binding, allowed namespaces, port 80
ListenerSetPer customerHostnames, TLS certificates
HTTPRoutePer customerRouting rules

Onboarding a new customer becomes: label the namespace, deploy the app with its ListenerSet and HTTPRoute. The shared Gateway doesn’t change.

The Migration Plan

Moving from central listeners to ListenerSets touches live traffic, so the order matters. Listener precedence drives the sequence. According to the Gateway API spec and Microsoft’s docs, when listeners conflict on hostname, port, or protocol:

  1. Listeners on the parent Gateway win.
  2. Then the oldest ListenerSet.
  3. Then alphabetical order by <namespace>/<name>.

The losing listener is marked conflicted and isn’t programmed. So a ListenerSet listener for app.customer-a.com sits there harmlessly until the Gateway listener for the same hostname is removed. That gives us a safe staging step.

Per customer, the plan is:

  1. Label the namespace with gateway-access: "true".
  2. Create the ListenerSet. Its HTTPS listener will be conflicted because the Gateway still has a listener for that hostname. That’s expected.
  3. Let cert-manager issue the new certificate. With the parentRef fallback, the HTTP-01 challenge goes through the Gateway’s shared port 80 listener, so issuance shouldn’t depend on the conflicted HTTPS listener. Wait for the Certificate in the customer namespace to be Ready.
  4. Add the ListenerSet as a second parentRef on the HTTPRoute, keeping the existing Gateway listener reference.
  5. Remove the customer’s listener from the Gateway. The ListenerSet listener should stop being conflicted and get programmed.
  6. Check status per listener, not just at the top level (see below), and confirm traffic.
  7. Clean up: drop the old Gateway parentRef from the HTTPRoute, and delete the old Certificate and Secret from the Gateway namespace.

Step 5 is the one I’m least sure about. What I don’t know yet is how AGC reprograms the frontend when a hostname moves from a Gateway listener to a ListenerSet listener, and whether there’s a gap while that happens. That’s the first thing we’ll test.

Open Questions We Still Need to Answer

These are the things the docs don’t settle for our setup.

Does our WAF policy follow the listeners? We need Web Application Firewall coverage on every customer hostname. Microsoft’s concept page is explicit that “policy target support is policy-specific. Don’t assume that every policy that can target a Gateway can also target a ListenerSet.” It also says that policies attached to routes keep applying when those routes use a ListenerSet as their parent. So we need to know whether a WAF policy targeting the Gateway covers listeners from ListenerSets, or whether we have to move WAF targeting to the HTTPRoutes or to each ListenerSet.

Does end-to-end TLS change at all? Backend TLS is configured per backend Service, not per listener, so I expect no change. But “I expect” isn’t “we verified”, and frontend TLS settings that target the Gateway or a listener sectionName raise the same question as WAF.

Are we comfortable running an alpha cert-manager feature in production? ListenerSet is GA in Gateway API and AGC supports it, but cert-manager still calls its own support alpha. Certificate automation is exactly the kind of thing you don’t want to break quietly. We’ll probably start with a single low-risk customer and watch renewals for a cycle or two.

How does status look on AGC in practice? The docs warn that a ListenerSet can report Accepted=True while one of its listeners is rejected. Our monitoring currently looks at Gateway conditions. We’ll need to look at per-listener conditions on every ListenerSet instead.

What ListenerSet Doesn’t Solve

Microsoft’s concept page has a section titled “Delegation isn’t infrastructure isolation”, and it’s the most honest part of the documentation. ListenerSets give you configuration ownership, not:

  • A separate AGC data plane
  • A separate frontend address
  • A separate scaling or failure domain
  • A complete security boundary between tenants

All customers still share the same AGC capacity and the same failure domain. That’s the same as today, but it’s worth stating because “each customer has their own ListenerSet” can easily sound like more isolation than it is.

There are some other sharp edges to keep in mind:

  • allowedListeners and namespace labels are routing changes. If a namespace stops matching the selector, AGC withdraws that namespace’s listeners from the data path. Removing a label should be treated with the same care as deleting a listener.
  • ReferenceGrants aren’t inherited. A grant that lets the Gateway read a Secret in another namespace doesn’t let a ListenerSet read it, and the other way round. Keeping each certificate in its ListenerSet’s namespace avoids the problem entirely.
  • The shared port 80 listener is shared. Every labeled namespace can attach routes to it, because cert-manager’s solver routes need to. RBAC and the namespace label are the guardrails here, not the Gateway.
  • RBAC does the actual access control. allowedListeners and allowedRoutes control which resources can attach. They don’t control who can create or edit them. That’s still Kubernetes RBAC.

For our setup, where small teams manage whole clusters, most of these are fine. Configuration ownership was the problem we actually had.

Corrections to Last Year’s Post

Two things in the old post were wrong or are now out of date:

  • The Gateway can’t have an empty listener list. I showed listeners: [] as the end state. That isn’t valid: a Gateway needs at least one listener (see gateway-api#4425). The cert-manager docs use a listener with a dummy hostname. With the HTTP-01 parentRef fallback, a real port 80 listener does the job and is useful too.
  • XListenerSet is now ListenerSet. The examples used gateway.networking.x-k8s.io/v1alpha1. The GA resource is gateway.networking.k8s.io/v1.

The cert-manager timeline also slipped a little. The 1.20 release with ListenerSet support came in March 2026 rather than February. Given the API itself went GA in the same window, that’s hardly a complaint.

Updated Recommendations

If you’re on AGC with central listeners, like us: the path is open, as long as you run the ALB Controller via Helm. Start with one customer, follow the precedence rules so you never have two live listeners for one hostname, and check your policies before assuming they follow the listeners.

If you’re on the AKS add-on: ListenerSet isn’t available to you yet. Decide whether switching to the Helm-installed controller is worth it, or wait for the add-on to get a release with ListenerSet support.

If you’re still on Ingress and evaluating Gateway API: the multi-tenancy argument against migrating has mostly gone away. ListenerSet gives you back per-app TLS ownership, cert-manager can drive it, and AGC supports it. What’s left is the usual migration work, plus the fact that cert-manager’s support is still alpha.

If you’re starting fresh: design around ListenerSet from day one. Keep the Gateway minimal and give each tenant namespace its own ListenerSet. Don’t build the growing listener list we built.

Next Up: Testing It

The plan is to stand this up on a non-production cluster: the 1.13.0 Helm chart, cert-manager with the ListenerSet feature gate, two test customers, our WAF policy, and end-to-end TLS. Then we’ll run the migration sequence above, including the moment where a hostname moves from the Gateway to a ListenerSet, while watching for dropped requests.

I’ll write up what actually happens, including whatever turns out to be wrong in this post.


If you’ve already run ListenerSet on AGC, especially with WAF, I’d love to hear how it went.