What is a shared ALB ingress group and why does one-ALB-per-Ingress get expensive?

By default, the AWS Load Balancer Controller provisions a separate Application Load Balancer for every Ingress resource it reconciles. Ten teams with two services each means twenty ALBs, each with its own listeners, security groups, and DNS name. An ingress group changes this. When several Ingresses carry the same alb.ingress.kubernetes.io/group.name annotation, the controller merges their rules onto a single shared ALB.

ALB pricing has two parts:

  • A fixed hourly charge for every hour the load balancer exists.
  • A usage-based charge measured in Load Balancer Capacity Units (LCUs), which track connections, bandwidth, and rule evaluations.

A low-traffic internal service consumes very few LCUs, so most of its bill is the hourly charge. Consolidation removes that duplicated fixed cost. LCU usage depends on traffic, so it stays roughly the same whether the traffic is spread across many ALBs or combined on one.

Illustrative estimate

The inputs are assumptions, not measured results: 20 Ingresses, an assumed rate of $0.0225 per ALB-hour, and 730 hours per month. LCU usage is low and roughly unchanged by consolidation, so it is left out.

Setup ALBs Fixed hours/month Fixed cost/month
One ALB per Ingress 20 14,600 ~$328.50
Shared ingress group 1 730 ~$16.43

Check current pricing for your region before using these numbers.

The operational savings matter as much as the cost savings. A shared ALB gives you:

  • One DNS target instead of twenty.
  • One set of access logs and alarms.
  • One security group to audit.
  • Fewer certificates to attach and track.

How does the AWS Load Balancer Controller merge Ingresses into one ALB?

The controller watches every Ingress carrying the same alb.ingress.kubernetes.io/group.name value, in any namespace, and reconciles them as a single unit. It builds one desired-state model for the whole group and maps it to one ALB. Because the group is reconciled together, an invalid annotation on one member can block updates for every Ingress in that group.

During that merge:

  • Listeners are combined. The ALB gets the union of the listen-ports declared across members. If one Ingress asks for HTTP:80 and another for HTTPS:443, the ALB gets both listeners.
  • Rules are combined. Each Ingress's host and path rules become listener rules. Their priority follows group.order first and Ingress name second. That ordering matters when two teams' paths overlap.
  • Backends stay separate. Each Service and port referenced by an Ingress gets its own target group. Health checks, target type, and backend protocol are configured per Ingress, so one team's misconfigured probe does not affect another team's targets.
flowchart LR
  subgraph ns-a[namespace: orders]
    I1[Ingress orders]
  end
  subgraph ns-b[namespace: billing]
    I2[Ingress billing]
  end
  I1 -- group.name: shared-public --> ALB
  I2 -- group.name: shared-public --> ALB
  ALB[ALB] --> L80[Listener :80]
  ALB --> L443[Listener :443]
  L443 --> R1[Rule: orders.example.com] --> TG1[TG orders-svc]
  L443 --> R2[Rule: /billing/*] --> TG2[TG billing-svc]

Some settings can only have one value per ALB. These are load-balancer-level:

  • scheme
  • subnets
  • security groups
  • WAF ACL
  • access logs
  • idle timeout and other load balancer attributes

Members must agree on these values. Conflicting values cause reconciliation errors instead of a silent override.

 namespace: orders                namespace: billing
 +--------------------------+     +--------------------------+
 | Ingress orders           |     | Ingress billing          |
 | group.name=shared-public |     | group.name=shared-public |
 | ports: HTTP:80, HTTPS:443|     | ports: HTTPS:443         |
 | host: orders.example.com |     | path: /billing/*         |
 +------------+-------------+     +------------+-------------+
              |                                |
              +----------------+---------------+
                               v  merged into one desired-state model
 +------------------------------------------------------------+
 | ALB  (one per group: shared-public)                        |
 | LB-level, members must agree: scheme, subnets,             |
 | security groups, WAF ACL, access logs, idle timeout        |
 |  +--------------+        +-----------------------------+   |
 |  | Listener :80 |        | Listener :443               |   |
 |  +--------------+        +-----+-----------------+-----+   |
 |                                |                 |         |
 |                      +---------+----------+ +----+-------+ |
 |                      | Rule: host         | | Rule: path | |
 |                      | orders.example.com | | /billing/* | |
 |                      +---------+----------+ +----+-------+ |
 +--------------------------------+-----------------+---------+
                                  v                 v
  per-Ingress settings:   +---------------+ +---------------+
  health check,           | TG orders-svc | | TG billing-svc|
  target type,            +-------+-------+ +-------+-------+
  backend protocol                v                 v
                          orders-svc Pods   billing-svc Pods

Two Ingresses in different namespaces share group.name shared-public and are merged into one ALB: listeners and rules are combined, load-balancer-level settings must agree, and each Ingress keeps its own target groups and backend settings.

How do you set up an ingress group across namespaces?

Start with two Ingresses: storefront in the shop namespace and payments in the billing namespace. Give both the same alb.ingress.kubernetes.io/group.name value, such as public-web, and apply them. The controller treats the group name as cluster-wide, so namespace boundaries do not split the group. Run kubectl get ingress -A. Both Ingresses should report the same ADDRESS hostname. If one shows a different address, or none, it was not merged.

To see what the controller built, find the load balancer with aws elbv2 describe-load-balancers. Pass its ARN to aws elbv2 describe-listeners, then pass each listener ARN to aws elbv2 describe-rules. The console's listener rules tab shows the same data. Every path and host rule from both Ingresses appears on one listener, with explicit priorities.

Rule priority matters when teams overlap. Suppose storefront routes api.example.com with path /*, and payments routes api.example.com/payments/*. The ALB stops at the first rule that matches. If the catch-all rule gets the higher priority, payment requests reach the storefront backend. Without explicit ordering, the controller sorts Ingresses by their identity, not by how specific their paths are. Set alb.ingress.kubernetes.io/group.order so that payments sorts before storefront. Lower values are evaluated first. After the change, run describe-rules again and confirm the new priorities.

Group-wide settings must match on every member. Typical examples are the scheme and other load balancer attributes. If one Ingress disagrees, the controller fails to reconcile and does not pick a winner. You see this in two places:

  • Ingress events: kubectl describe ingress shows a warning event that names the conflicting setting.
  • Controller logs: the logs record the same error.

While the conflict stands, the controller cannot apply changes from any member of the group.

# payments (billing namespace): specific path, so it must be evaluated first.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: payments
  namespace: billing
  annotations:
    alb.ingress.kubernetes.io/group.name: public-web   # same value = same ALB
    alb.ingress.kubernetes.io/group.order: "10"        # lower value = higher rule priority
    alb.ingress.kubernetes.io/scheme: internet-facing  # group-wide: must match all members
spec:
  ingressClassName: alb
  rules:
    - host: api.example.com
      http:
        paths:
          - path: /payments
            pathType: Prefix
            backend:
              service: {name: payments-svc, port: {number: 80}}
---
# storefront (shop namespace): catch-all, so it must be evaluated after payments.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: storefront
  namespace: shop
  annotations:
    alb.ingress.kubernetes.io/group.name: public-web
    alb.ingress.kubernetes.io/group.order: "20"
    alb.ingress.kubernetes.io/scheme: internet-facing  # a different scheme here breaks reconciliation
spec:
  ingressClassName: alb
  rules:
    - host: api.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service: {name: storefront-svc, port: {number: 80}}

Two Ingresses in different namespaces join the public-web group on one ALB, and group.order places the specific /payments rule ahead of the storefront catch-all.

How do you stop teams from attaching to ALB groups they don't own?

Group membership is decided by a single annotation, alb.ingress.kubernetes.io/group.name. The controller does not check who set it. Any namespace with permission to create an Ingress can join an existing group by using the same name. Once it joins, its rules go onto the shared listener next to everyone else's. A team could claim a host another team serves, or add a broader path that matches first. The group.order annotation makes this worse, because a newcomer can give its rules a lower order value and have them evaluated ahead of existing ones. None of this needs access to the other team's namespace.

The fix is to take the group decision away from individual Ingresses. An IngressClassParams resource is cluster-scoped, so only cluster administrators normally write to it. It can do two things:

  • Pin the group name. It sets the group for every Ingress that uses the class, and that setting takes precedence over anything the Ingress declares.
  • Restrict who can use the class. Its namespaceSelector limits the class to namespaces with matching labels. The controller rejects an Ingress from any other namespace instead of reconciling it.

To connect the two, point an IngressClass at the params object through spec.parameters. Give each tenant boundary its own class, then control the namespace labels the selectors match on.

Admission policy adds a check that runs before an object is stored. A validating webhook or policy engine can do three useful things:

  • Reject Ingresses that set the group or order annotations directly.
  • Require a specific ingressClassName for each namespace.
  • Check that each requested host belongs to the namespace asking for it.

The controller only checks class and group, not hostnames, so that last rule closes the remaining gap.

# Cluster-scoped params: only cluster admins can write these.
apiVersion: elbv2.k8s.aws/v1beta1
kind: IngressClassParams
metadata:
  name: team-payments
spec:
  # Only namespaces carrying this label may use the class.
  # Admins own the label, so tenants cannot opt themselves in.
  namespaceSelector:
    matchLabels:
      alb-tenant: payments
  # Pinned group: overrides any group.name annotation on the Ingress.
  group:
    name: payments-shared
  scheme: internet-facing
---
# The class tenants reference. It points at the params above.
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: alb-payments
spec:
  controller: ingress.k8s.aws/alb
  parameters:
    apiGroup: elbv2.k8s.aws
    kind: IngressClassParams
    name: team-payments
---
# A tenant Ingress. It has no group annotation and selects only the class.
# The controller rejects it if its namespace lacks the alb-tenant=payments label.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: checkout
  namespace: payments-checkout
spec:
  ingressClassName: alb-payments
  rules:
    - host: checkout.payments.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service: { name: checkout, port: { number: 80 } }

An admin-owned IngressClassParams pins the ALB group and limits the class to labeled namespaces, and tenant Ingresses select the group only through ingressClassName.

How does TLS work when several Ingresses share one ALB?

An ALB has one HTTPS listener per port, and every Ingress in the group that requests that port shares it. The controller combines the certificates from all member Ingresses into that listener's certificate list. When a client connects, the ALB reads the hostname from the TLS Server Name Indication (SNI) extension and picks the best-matching certificate from the list. This happens during the handshake, before any host-based routing rule runs. A matching certificate does not mean a matching rule exists, and a matching rule does not mean the right certificate is attached.

Each Ingress either sets alb.ingress.kubernetes.io/certificate-arn explicitly or falls back to auto-discovery. With auto-discovery, the controller looks up ACM certificates that cover the hosts declared in that Ingress. The choice is made per Ingress, so a group can mix both approaches. Team A can pin an ARN while team B relies on discovery, and the listener ends up with both certificates. Auto-discovery will fail if no ACM certificate covers a host, so the Ingress needs a matching certificate in ACM before you deploy it.

The listener also has one default certificate. The ALB serves it to clients that send no SNI or a hostname that no attached certificate matches. When several Ingresses contribute certificates, it is not obvious which one becomes the default. Avoid relying on it, and make sure every served hostname is covered by a certificate in the list.

ALB limits how many certificates a listener can hold. Look up your account's current value in Service Quotas instead of assuming a number. Wildcard certificates help a large group stay under the limit.

# Team A pins an explicit ACM certificate ARN.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: team-a
  annotations:
    alb.ingress.kubernetes.io/group.name: shared-public
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/listen-ports: '[{"HTTPS":443}]'
    alb.ingress.kubernetes.io/certificate-arn: arn:aws:acm:us-east-1:111122223333:certificate/aaaa1111-placeholder
spec:
  ingressClassName: alb
  rules:
    - host: app.team-a.example.com
      http:
        paths:
          - {path: /, pathType: Prefix, backend: {service: {name: team-a-web, port: {number: 80}}}}
---
# Team B sets no certificate-arn. The controller discovers an ACM certificate
# covering the tls hosts, and an issued certificate must already exist for them.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: team-b
  annotations:
    alb.ingress.kubernetes.io/group.name: shared-public
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/listen-ports: '[{"HTTPS":443}]'
spec:
  ingressClassName: alb
  tls:
    - hosts: ["api.team-b.example.com"]
  rules:
    - host: api.team-b.example.com
      http:
        paths:
          - {path: /, pathType: Prefix, backend: {service: {name: team-b-api, port: {number: 80}}}}
# Result: one HTTPS:443 listener on the shared ALB with both certificates attached.
# SNI chooses the certificate first, and the host rules route the request afterward.

Two Ingresses in the same ALB group add certificates to one shared HTTPS:443 listener. One pins an explicit ARN and the other relies on ACM auto-discovery from its TLS hosts.

How do you safely add, remove, and migrate Ingresses in a group?

When one Ingress leaves the group, by deletion or by removing its group annotation, the controller deletes only that Ingress's listener rules and target groups. The ALB, its DNS name, and the other members' rules stay in place. When the last member is deleted, the controller deletes the ALB itself. Any DNS record still pointing at that ALB then resolves to nothing, so retire records before you retire the last Ingress.

Migrating a standalone Ingress into a group

  1. Lower the TTL on the service's DNS record ahead of time so the cutover propagates quickly.
  2. Create a copy of the Ingress under a new name with the group annotation and the same rules and backends. Leave the original untouched. Both ALBs now register the same pods in separate target groups.
  3. Test the shared ALB directly by sending requests to its DNS name with the correct Host header.
  4. Repoint DNS to the shared ALB. Clients with cached answers keep using the old ALB, so their in-flight connections finish normally.
  5. Watch the old ALB's request count drop to zero for longer than the old TTL. Then delete the original Ingress.

Operational checks

A bad annotation on one member can block reconciliation for the whole group. Alert on warning events from kubectl describe ingress and on errors in the controller logs, not just on your own Ingress.

Apply ownership and cost tags through the controller's tags annotation so the generated target groups carry them. Use per-target-group CloudWatch metrics to separate one team's traffic from another's. ALB access logs include the target group ARN for each request, which lets you attribute a slow or failing request to a specific team.

When should you avoid a shared ALB, and what are the alternatives?

A shared ALB pays off for platform teams running many low-traffic services, where each ALB's fixed hourly charge outweighs the traffic it carries. Outside that case, the coupling can cost more than it saves.

  • Blast radius. A deleted listener, a broken security group or a misconfigured WAF association affects every service on the ALB, not just one.
  • Reconciliation coupling. The controller reconciles a group as a single unit. One Ingress with an invalid annotation or a missing Service can stall deploys for every team in that group until someone fixes it.
  • Quotas. Rules per ALB, certificates per listener and target groups per ALB all have limits. A busy group reaches them sooner than you might expect.
  • Shared settings. Idle timeout, access logging, WAF and IP address type apply to the whole ALB. If two teams need different values, their Ingresses conflict.
  • Rule ordering. Overlapping hosts or paths are resolved by group order. A new Ingress can silently take traffic that another team's rule used to receive.
  • Cost attribution. One bill line has to be split across teams using metrics and logs.
  • Small savings at high volume. For a few high-traffic services, LCU charges dominate the bill and scale with traffic no matter how you consolidate. Removing a few hourly charges changes little.
Approach Cost Isolation Engineering effort
One ALB per Ingress Highest fixed cost Strongest Lowest
Several groups split by team or requirement Moderate Good within each group Moderate: you have to define and enforce the boundaries
In-cluster ingress controller behind one load balancer Lowest Weakest; routing runs on shared pods Highest: you operate, scale and patch the proxy

How OneEnv can help

Disclosure: OneEnv is the product behind this blog.

OneEnv (oneenv.io) is a workspace-based governance platform for the things services share — environment variables, database structure, API routes and validation rules. A change to a shared value is staged on a branch, reviewed once, and then every affected service explicitly approves or rejects it before it goes live, so you can see who a change touches before it ships instead of finding out in production.

Applied to shared alb ingress group, this is where it helps:

Saves time

  • Every service that inherits a shared value is listed in one place, so nobody searches repos and chats to find out who is affected.
  • One review per branch replaces coordinating each team separately; each service still keeps its own approve/reject.
  • The dependency graph answers "what does this touch?" in seconds instead of a manual audit.

Saves cost

  • Fewer production incidents and rollbacks caused by a shared value, route or column changing under a consumer unannounced.
  • Less duplicated configuration to maintain: one shared definition inherited by many services.
  • You can size a change's blast radius before merging, avoiding surprise cross-team firefighting.
  • OneEnv has a free plan (1 workspace, unlimited services and members, full governance), so trying it costs nothing.

These are qualitative benefits, not measured results — how much you save depends on how many services share the value.

Want to try it? Start at oneenv.io.