What is a shared ALB for Kubernetes Ingress, and why does the default create one ALB per Ingress?

By default, the AWS Load Balancer Controller treats every Ingress resource as its own implicit group and provisions a dedicated Application Load Balancer for it. Twenty Ingresses produce twenty ALBs, each with its own DNS name, listeners, and security groups. A shared ALB reverses this: with ingress groups, many Ingresses join a named group through the alb.ingress.kubernetes.io/group.name annotation, optionally across namespaces. The controller merges their rules into one ALB's listeners.

The default isolates services, so a misconfigured rule in one Ingress cannot affect another. The cost of that isolation comes from how ALB pricing works. Each load balancer incurs a fixed hourly charge whether it serves traffic or not, plus a usage charge measured in Load Balancer Capacity Units (LCUs). For a busy service, LCUs dominate. For a quiet internal API, the fixed charge is most of the bill.

Illustrative estimate. These are placeholder prices, not real AWS pricing. Assume a fixed charge of $X per ALB-month and LCU usage of $Y per service-month, with 30 low-traffic services:

Setup ALBs Fixed charges LCU charges Total
One ALB per Ingress 30 30X ≈30Y 30X + 30Y
One shared ALB 1 1X ≈30Y X + 30Y

LCU usage stays roughly constant because the traffic is the same. Consolidation removes the duplicated fixed charges.

Platform teams running many small HTTP services gain the most from this. Their bill is mostly fixed charges, and consolidation also reduces the number of DNS records, certificates, and security groups they have to manage.

How do ingress groups work in the AWS Load Balancer Controller?

Add alb.ingress.kubernetes.io/group.name: shared-public to several Ingresses, and the AWS Load Balancer Controller treats them as one unit. Each group gets one ALB. Ingresses without the annotation each form their own implicit group, which is why the default is one ALB per Ingress. Group membership is not limited by namespace, so Ingresses owned by different teams can share a load balancer.

When any member changes, the controller rebuilds the whole group. It collects every member's rules and computes a single desired state for the ALB:

  • Listeners: the union of every member's listen-ports.
  • Certificates: merged onto the HTTPS listener.
  • Target groups: one per referenced Service and port.

It then compares this desired state with the live ALB and updates it.

Rule priority comes from alb.ingress.kubernetes.io/group.order. This is an integer where lower values are evaluated first. Ingresses that share an order value are sorted by namespace and name. Rules inside a single Ingress keep the order in which they are written.

That ordering matters because the controller does not detect overlapping host and path combinations. If two members both claim api.example.com/, the controller creates both rules. The ALB evaluates rules by priority, so the lower-priority rule never matches any traffic. Nothing reports an error, so treat this as a review-time check.

Listener-level and load-balancer-level settings work differently. If one member sets a different scheme, or a different SSL policy on the same port, the controller cannot merge the values. It reports an error on the group and stops reconciling it until the members agree. The next section covers which settings fall into this category.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api
  namespace: team-api
  annotations:
    alb.ingress.kubernetes.io/group.name: shared-public   # same group => same ALB
    alb.ingress.kubernetes.io/group.order: "10"           # lower value, rules evaluated first
    alb.ingress.kubernetes.io/scheme: internet-facing     # LB-level: must match across members
    alb.ingress.kubernetes.io/target-type: ip
spec:
  ingressClassName: alb
  rules:
    - host: api.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend: {service: {name: api-svc, port: {number: 8080}}}  # own target group
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
  namespace: team-web                                     # different namespace, same ALB
  annotations:
    alb.ingress.kubernetes.io/group.name: shared-public
    alb.ingress.kubernetes.io/group.order: "20"           # evaluated after team-api's rules
    alb.ingress.kubernetes.io/scheme: internet-facing     # a different value here would block the group
    alb.ingress.kubernetes.io/target-type: ip
spec:
  ingressClassName: alb
  rules:
    - host: www.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend: {service: {name: web-svc, port: {number: 80}}}    # second target group

Two Ingresses in different namespaces join the shared-public group, so the controller merges them into one ALB. Each Service gets its own target group, group.order sets rule precedence, and the scheme value matches on both members.

Which annotations must agree across the group and which can differ?

The settings fall into two groups. Some describe the load balancer itself, so every member contributes to one shared value. Others describe a rule or a target group, so each Ingress keeps its own.

Scope Annotations (by concept) Effect of disagreement
Per-ALB scheme, subnets, security groups, load balancer attributes (idle timeout, access logs, deletion protection), WAF association Conflicting values put the group in an error state
Per-listener listen ports, SSL policy, certificates Ports and certificates merge; conflicting SSL policy errors
Per-rule / per-backend health checks, target type, conditions, actions Each Ingress or Service keeps its own value

The per-ALB settings are the ones that cause unexpected behaviour. An ALB has one scheme, one set of subnets and one idle timeout. Two members that set different values put the group in an error state. A value set by only one member applies to the whole ALB, which can be worse because nothing fails. For example, a team that sets a 300-second idle timeout or attaches a WAF ACL changes behaviour for every service in the group. A service that needs a different ALB-level value cannot override it locally. It has to leave the group and get its own load balancer.

TLS works per listener. The controller attaches every certificate from all members to the shared HTTPS listener, and the ALB uses SNI to select the correct certificate for each host. You can list certificate ARNs explicitly, or leave them out and let the controller find matching ACM certificates from the hostnames in each Ingress. Explicit ARNs are predictable. Discovery is convenient, but it fails if no matching certificate is issued. ALBs have a per-load-balancer certificate quota, which you can check and raise through Service Quotas. Each new hostname uses part of that quota, so plan capacity for it before adding many tenants to one group.

# Two Ingresses sharing one ALB through group.name.
# ALB-level annotations are identical in both members.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: orders
  namespace: shop
  annotations:
    alb.ingress.kubernetes.io/group.name: shared-public    # same ALB
    alb.ingress.kubernetes.io/scheme: internet-facing      # per-ALB: must match
    alb.ingress.kubernetes.io/load-balancer-attributes: idle_timeout.timeout_seconds=60  # per-ALB: must match
    alb.ingress.kubernetes.io/listen-ports: '[{"HTTPS":443}]'
    # Explicit ARN: merged onto the shared HTTPS listener, served by SNI
    alb.ingress.kubernetes.io/certificate-arn: arn:aws:acm:us-east-1:123456789012:certificate/11111111-2222-3333-4444-555555555555
    alb.ingress.kubernetes.io/target-type: ip              # per-backend: may differ
    alb.ingress.kubernetes.io/healthcheck-path: /healthz   # per-target-group: may differ
spec:
  ingressClassName: alb
  rules:
    - host: orders.example.com
      http:
        paths:
          - {path: /, pathType: Prefix, backend: {service: {name: orders, port: {number: 80}}}}
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: search
  namespace: shop
  annotations:
    alb.ingress.kubernetes.io/group.name: shared-public
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/load-balancer-attributes: idle_timeout.timeout_seconds=60
    alb.ingress.kubernetes.io/listen-ports: '[{"HTTPS":443}]'
    # No certificate-arn: controller discovers an issued ACM cert for the tls host
    alb.ingress.kubernetes.io/target-type: instance
    alb.ingress.kubernetes.io/healthcheck-path: /ready
spec:
  ingressClassName: alb
  tls:
    - hosts: [search.example.com]
  rules:
    - host: search.example.com
      http:
        paths:
          - {path: /, pathType: Prefix, backend: {service: {name: search, port: {number: 80}}}}

Two Ingresses in one group repeat the same ALB-level annotations while keeping their own target type and health check, and they contribute certificates to the shared HTTPS listener, one with an explicit ARN and one through hostname discovery.

How do you enforce group membership and shared settings with IngressClass and IngressClassParams?

Instead of asking every team to copy the same group.name, scheme, and tag annotations, the platform team defines one cluster-scoped IngressClass whose spec.controller is ingress.k8s.aws/alb and whose spec.parameters points at an IngressClassParams object. That object holds the shared settings centrally: the group name, the scheme, the IP address type, tags, and other load-balancer-level fields. An application team then sets ingressClassName on its Ingress and leaves those annotations out.

Why this beats annotations

When IngressClassParams specifies a group, every Ingress using that class joins that group, and the controller does not allow the group.name annotation on those Ingresses. This blocks two failure modes. A team cannot join a group by accident by mistyping a name, and it cannot deliberately join someone else's ALB to attach rules to a hostname it does not own. Pinning the scheme in the same object means no Ingress can turn an internal ALB into an internet-facing one.

Restricting who can use a class

IngressClassParams has a namespaceSelector. If an Ingress in a namespace that doesn't match the selector references the class, the controller rejects it. Use RBAC to limit who can create or edit IngressClass and IngressClassParams objects. Plain RBAC cannot check field values, so add a ValidatingAdmissionPolicy that does three things:

  • Requires an approved ingressClassName.
  • Rejects listener-affecting annotations such as listen-ports.
  • Rejects Ingresses that set no class at all.

This is where the setup saves engineering time. Teams ship Ingresses without negotiating ALB settings with the platform team each time, and the shared configuration changes in only one place.

# Platform-owned: shared ALB settings live here, not in app annotations.
apiVersion: elbv2.k8s.aws/v1beta1
kind: IngressClassParams
metadata:
  name: shared-internal-alb
spec:
  # Only namespaces carrying this label may use the class.
  namespaceSelector:
    matchLabels:
      platform.example.com/alb-group: shared-internal
  # Every Ingress using this class joins this group; group.name annotations are not allowed.
  group:
    name: shared-internal
  # Pinned so no Ingress can make the ALB internet-facing.
  scheme: internal
  ipAddressType: ipv4
  tags:
    - key: owner
      value: platform-team
---
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: alb-shared-internal
spec:
  controller: ingress.k8s.aws/alb
  parameters:
    apiGroup: elbv2.k8s.aws
    kind: IngressClassParams
    name: shared-internal-alb
---
# App-owned: references the class and sets no ALB-level annotations.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: orders
  namespace: orders
spec:
  ingressClassName: alb-shared-internal
  rules:
    - host: orders.internal.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: orders
                port:
                  number: 80

A platform-owned IngressClassParams sets the group, scheme, IP address type and tags, and restricts the class to labeled namespaces. An application Ingress joins the shared ALB by setting only ingressClassName.

When should you avoid sharing one ALB?

Sharing an ALB also couples teams in ways that don't show up until something breaks.

Blast radius. The controller reconciles a group as a single unit. If one Ingress has a malformed annotation, a rule that conflicts with another member, or a certificate ARN that doesn't resolve, the whole group fails to build. No changes are applied for any member until the bad Ingress is fixed, so one team's mistake stalls everyone else's deploys.

Rule precedence. Rules from all members end up on the same listeners. A broad host wildcard or a catch-all path in one Ingress can shadow more specific routes owned by another team. Explicit group.order values help, but they turn routing into a shared registry that someone has to govern.

Noisy neighbors. The ALB scales as one resource. It has no per-service throttling, so a traffic spike to one backend consumes capacity that every other member shares.

Security boundaries. Scheme (internet-facing or internal), security groups and an attached WAF web ACL apply to the whole ALB. Tenants with different trust levels inherit each other's exposure.

Cost attribution. You get one ALB bill. Splitting it per team means deriving usage from per-target-group metrics or access logs.

Quotas. Each ALB and listener has hard limits on rules, target groups and certificates. A single group for everything reaches them sooner. Check your account's Service Quotas before you consolidate.

Draw group boundaries along lines where the settings already match:

Boundary Shares well when Split when
Domain Same certificate set and owners Teams deploy independently
Environment Same scheme and WAF policy Prod and non-prod would mix
Trust level Same exposure and security groups Public and internal tenants would mix

How do you migrate from per-service ALBs to a shared ingress group?

Run the old and new paths side by side so that rollback is just a DNS change. Each ALB has its own generated DNS name, and your records (usually CNAME or alias records) point at that name. The cutover is therefore a DNS change, and DNS caching means it does not take effect everywhere at once.

Steps

  1. Create grouped copies. Deploy new Ingress objects with alb.ingress.kubernetes.io/group.name set and new resource names. Leave the originals untouched. The controller provisions one new ALB for the group.
  2. Verify before traffic. Use kubectl get ingress -n <ns> to confirm that the new address is populated. Check rule merging with kubectl describe ingress <name> -n <ns>. Reconcile failures appear as events, which you can list with kubectl get events -n <ns> --field-selector involvedObject.kind=Ingress. Then confirm target health, the WAF association, and any authentication actions on the new ALB itself. A merged rule set can differ from what each team tested alone.
  3. Shift DNS gradually. If external-dns watches both Ingresses for the same host, the two resources compete for one record. Exclude one of them from its scope, or manage weighted records deliberately and move weight in steps.
  4. Wait, then delete old Ingresses. Keep the old ALBs until the record TTLs and client caches have expired.

Teardown order matters in the other direction too. Deleting the last member of a group deletes its ALB, and recreating the group produces a different DNS name. Never delete and recreate all group members at once.

#!/usr/bin/env bash
# Read-only checks during cutover from per-service ALBs to a shared ingress group.
set -euo pipefail
NS=shop
OLD=shop-api            # original per-service Ingress
NEW=shop-api-grouped    # copy with alb.ingress.kubernetes.io/group.name set
GROUP=shop-public
HOST=api.example.com

# 1. Both Ingresses should show an ADDRESS. Each address is a different ALB DNS name.
kubectl get ingress "$OLD" "$NEW" -n "$NS" -o wide

# 2. Merged rules, backends and annotations as the controller sees them.
kubectl describe ingress "$NEW" -n "$NS"

# 3. Reconcile errors (bad annotations, conflicting rules, IAM failures) surface as events.
kubectl get events -n "$NS" \
  --field-selector involvedObject.kind=Ingress,involvedObject.name="$NEW" \
  --sort-by=.lastTimestamp

# 4. Target health on the new ALB's target groups (the TargetGroupBinding CRD holds the ARNs).
for arn in $(kubectl get targetgroupbindings -n "$NS" -o jsonpath='{.items[*].spec.targetGroupARN}'); do
  aws elbv2 describe-target-health --target-group-arn "$arn" \
    --query 'TargetHealthDescriptions[].[Target.Id,TargetHealth.State]' --output text
done

# 5. Check which ALB the public record currently resolves to.
dig +short "$HOST"

# 6. Before deleting anything, list every member of the group across namespaces.
#    If the Ingress you plan to delete is the only member, deleting it removes the ALB.
kubectl get ingress -A -o custom-columns='NS:.metadata.namespace,NAME:.metadata.name,GROUP:.metadata.annotations.alb\.ingress\.kubernetes\.io/group\.name,ADDRESS:.status.loadBalancer.ingress[0].hostname' \
  | awk -v g="$GROUP" 'NR==1 || $3==g'

# Delete the OLD Ingress only after the DNS TTL has expired and step 5 shows the new ALB:
# kubectl delete ingress "$OLD" -n "$NS"

Read-only kubectl, AWS CLI, and dig checks for cutover: compare old and new ALB addresses, inspect merged rules and reconcile events, confirm target health, see where DNS points, and list the group's members before any deletion.

How do you operate a shared ALB, and what are the alternatives?

Operating the group

Give every group a named owning team, recorded in the IngressClass or a label. The ALB is shared state, so someone has to approve changes that touch it. Route annotation edits on member Ingresses through code review or an admission policy. One malformed annotation can block reconciliation for the whole group, not just for the service that made the edit.

Alert on reconcile failures from two sources:

  • Warning events on Ingress objects. These show which member broke.
  • Error lines in the controller logs. These catch failures that never surface as events.

A silent failure here means later changes from every team stop applying, which is easy to miss.

For per-service visibility, use CloudWatch's target-group dimension. Request count, target 5xx and response time all break down per target group. Apply consistent tags with team and service keys to the target groups.

Chargeback is approximate. Hourly and capacity charges belong to the ALB as a whole, so split them by each target group's share of requests or bytes.

Alternatives

Option Cost Isolation Operational effort
One ALB per Ingress Highest; per-ALB hourly charge multiplies Strongest; blast radius is one service Low per service, high in aggregate
In-cluster controller behind one load balancer Low AWS spend; adds cluster compute Weak; shared proxy pods and config High; you run and scale the proxy
Gateway API Depends on the implementation Role split between platform and app teams is built into the model Moderate; maturity varies by implementation
NLB for non-HTTP Separate per-NLB cost Per service Low; no layer-7 routing to manage

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 kubernetes ingress, 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.
  • Reviewers see the exact diff and the list of affected services up front, so approval is a decision rather than an investigation.

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.
  • Per-service approve/reject means a bad shared value can be refused where it would break something, before it is live.
  • 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.