How does ALB pricing work, and why does one ALB per Ingress get expensive?

An Application Load Balancer bills on two meters. The first is a fixed charge for every hour, or partial hour, the load balancer exists, whether or not it serves traffic. The second is Load Balancer Capacity Units (LCU-hours). Each hour, AWS measures four dimensions, converts each to LCUs, and bills only the highest one. Rates vary by region and change over time, so check the AWS Elastic Load Balancing pricing page before you model anything.

LCU dimension What it measures
New connections Newly established connections per second
Active connections Concurrent connections, sampled per minute
Processed bytes Request and response bytes handled
Rule evaluations Listener rules processed per second, beyond a free allowance

By default, the AWS Load Balancer Controller provisions one ALB per Ingress resource. A cluster with 40 Ingresses therefore has 40 ALBs, and each pays the full fixed hourly charge. An internal admin tool that handles a few requests a minute uses a small fraction of one LCU, so nearly all of its load balancer bill is the fixed charge.

The fixed charge is not the only cost that scales with the number of load balancers:

  • Public IPv4 addresses. An internet-facing ALB holds a public address in each enabled subnet, and AWS bills public IPv4 addresses hourly.
  • WAF. Separate web ACLs per ALB add per-ACL and per-rule charges. Even when ALBs share one web ACL, every association is another thing to configure and audit.
  • Logging and monitoring. Each ALB needs its own access-log configuration, and alarms are usually defined per load balancer.

This matters most to platform teams that run many small services through the controller. In that setup, the number of ALBs drives cost more than traffic does.

What is an ingress group and how does it work in the AWS Load Balancer Controller?

The AWS Load Balancer Controller normally creates one ALB for each Ingress. An ingress group changes that. Every Ingress with the same alb.ingress.kubernetes.io/group.name value is reconciled as one unit and shares a single ALB. Ingresses in the group can be in different namespaces.

Here is a before-and-after with three services:

Before: orders Ingress → ALB 1 · users Ingress → ALB 2 · billing Ingress → ALB 3

After: orders + users + billing (all with group.name: shop) → one ALB → shared :443 listener → rules from all three, ordered by group.order

The controller merges each member's host and path rules onto listeners keyed by port. Two Ingresses that both declare HTTPS on 443 end up on the same listener. Because all members now share one rule list, precedence matters. alb.ingress.kubernetes.io/group.order sets each Ingress's position, and lower values are evaluated first. Without explicit orders, a broad rule such as /* from one team can catch traffic meant for a more specific path in another team's Ingress.

Some settings belong to the ALB or its listeners, not to individual rules:

  • security groups
  • WAF association
  • idle timeout
  • access logs
  • SSL policy

These apply to every member of the group. When members declare different values for these settings, the controller cannot apply both, and reconciliation of the group fails. In practice, one team cannot change these settings without coordinating with every other team in the group. That is the main operational cost of consolidation.

# Two Ingresses in different namespaces join the same group and share one ALB.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: billing
  namespace: billing
  annotations:
    alb.ingress.kubernetes.io/group.name: shop        # same value = same ALB
    alb.ingress.kubernetes.io/group.order: "10"       # specific path, evaluated first
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/listen-ports: '[{"HTTPS":443}]'  # merged onto the shared :443 listener
    # ALB-level settings: every member must declare identical values (or omit them)
    alb.ingress.kubernetes.io/load-balancer-attributes: idle_timeout.timeout_seconds=60
spec:
  ingressClassName: alb
  rules:
    - host: shop.example.com
      http:
        paths:
          - path: /billing
            pathType: Prefix
            backend: {service: {name: billing, port: {number: 80}}}
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: storefront
  namespace: web
  annotations:
    alb.ingress.kubernetes.io/group.name: shop
    alb.ingress.kubernetes.io/group.order: "100"      # catch-all goes last so it can't shadow /billing
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/listen-ports: '[{"HTTPS":443}]'
    alb.ingress.kubernetes.io/load-balancer-attributes: idle_timeout.timeout_seconds=60  # must match billing
spec:
  ingressClassName: alb
  rules:
    - host: shop.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend: {service: {name: storefront, port: {number: 80}}}

Two Ingresses in different namespaces share the group name "shop", so their rules merge onto one ALB's :443 listener, with group.order putting the specific /billing rule ahead of the catch-all and the ALB-level idle timeout set to the same value on both.

How much can you save by consolidating ALBs? An illustrative estimate

The savings come from two places: fixed hourly charges you stop paying, and LCU billing that does not add up linearly. Each ALB bills, every hour, only its highest LCU dimension (new connections, active connections, processed bytes, or rule evaluations). Combine services that peak on different dimensions, and the maximum of the summed traffic can be lower than the sum of each ALB's maximum.

Illustrative estimate (assumed numbers, not a benchmark). These inputs are placeholders. Substitute your region's actual rates.

  • 20 small services, 730 hours/month
  • Assumed ALB rate: $0.025/hour. Assumed LCU rate: $0.008/LCU-hour
  • Each service alone averages 0.3 billed LCU/hour, so the 20 separate ALBs total 6.0
  • Combined onto one ALB, the summed traffic averages 4.5 billed LCU/hour, because byte-heavy and connection-heavy services no longer each pay for their own peak dimension
  • Split across three ALBs, the total is 5.0

Monthly cost = 730 × (ALB count × hourly rate + LCU rate × total billed LCU/hour)

Layout Fixed LCU Total/month
20 ALBs $365.00 $35.04 $400.04
3 shared ALBs $54.75 $29.20 $83.95
1 shared ALB $18.25 $26.28 $44.53

Of the $355.51 saved with one ALB, $346.75 comes from removed fixed charges. The LCU effect is real but secondary.

The picture changes when the original ALBs were already busy. Suppose each of the 20 ALBs billed 50 LCU/hour. LCU charges would then be $5,840/month against $365 in fixed fees. Consolidation would remove at most about 6% of the bill, and likely less once rule evaluations grow on the shared listener.

How do rule evaluations change LCU costs on a consolidated ALB?

Rule evaluations are the LCU dimension that most often surprises teams after consolidation. Each Ingress merged into a group adds its rules to the shared listener, and the ALB checks rules in priority order until one matches. Only the first 10 rules processed per request are free. Every rule beyond that counts, and 1,000 rule evaluations per second equals one LCU. The ALB bills only the highest of its LCU dimensions each hour, so a rule-dense listener with steady traffic can make rule evaluations the dimension you pay for.

Illustrative estimate (assumed numbers, not a benchmark)

  • LCU from rules = request rate × (rules processed − 10) ÷ 1,000
  • Assume 2,000 requests/second and an average of 40 rules processed before a match: 2,000 × 30 ÷ 1,000 = 60 LCU
  • At an assumed $0.008 per LCU-hour: 60 × 730 × $0.008 ≈ $350/month, but only if this exceeds the ALB's other LCU dimensions
  • Reorder so the average match happens at rule 12: 2,000 × 2 ÷ 1,000 = 4 LCU

How to keep evaluations low

  • Order rules by traffic. alb.ingress.kubernetes.io/group.order sets the order of whole Ingresses within a group, with lower values evaluated first. Give low values to the Ingresses with the most traffic and the most specific rules. Within one Ingress, rules keep the order they have in the spec.
  • Use host-based routing. A request that matches its hostname early skips the path rules that belong to other services.
  • Check quotas before merging. Limits apply to rules per listener, target groups per load balancer, and certificates per listener. Some can be raised through Service Quotas. Others, such as conditions per rule, are fixed. Check the current values in the Service Quotas console before you plan a large group.
# Two Ingresses merged into one ALB via the same group.name.
# Lower group.order values are evaluated first on the shared listener.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api-hot-path
  annotations:
    alb.ingress.kubernetes.io/group.name: shared-public
    alb.ingress.kubernetes.io/group.order: "10"   # highest-traffic service goes first
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/target-type: ip
spec:
  ingressClassName: alb
  rules:
    - host: api.example.com          # host match ends evaluation early for most requests
      http:
        paths:
          - path: /v1/orders         # most specific path first; spec order is kept
            pathType: Prefix
            backend: { service: { name: orders, port: { number: 80 } } }
          - path: /
            pathType: Prefix
            backend: { service: { name: api-gateway, port: { number: 80 } } }
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: admin-low-traffic
  annotations:
    alb.ingress.kubernetes.io/group.name: shared-public
    alb.ingress.kubernetes.io/group.order: "900"  # rarely hit, evaluated late
spec:
  ingressClassName: alb
  rules:
    - host: admin.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend: { service: { name: admin-ui, port: { number: 80 } } }

Two Ingresses share one ALB through group.name, with group.order and host-based rules arranged so the busiest, most specific routes match in the first few rule evaluations.

When should you avoid sharing an ALB across Ingresses?

Some differences force separate ALBs because the setting belongs to the load balancer or listener, not to an individual rule. The controller merges every Ingress in a group into one ALB, so these settings must agree across all members.

Boundary Scope on the ALB Why it blocks sharing
Scheme (internet-facing vs internal) Load balancer Fixed at creation. One ALB cannot be both.
Subnets / VPC placement Load balancer All rules use the same network placement.
Security groups Load balancer Inbound access is the same for every hostname on the ALB.
WAF web ACL Load balancer One ACL applies to all traffic, so you cannot give a single app a stricter ruleset.
TLS policy / listener ports Listener One SSL policy per listener. A legacy client needing older ciphers weakens TLS for every tenant on that port.

Even when the settings are compatible, sharing carries operational risk:

  • Blast radius. The controller reconciles a group as a unit. A typo in an annotation or a missing certificate ARN in one Ingress can stop updates to the ALB for every Ingress in the group until someone fixes it.
  • Setting conflicts. If two Ingresses set different values for a group-wide annotation, the controller reports an error. It does not pick a winner.
  • Noisy neighbors. One team's traffic spike or slow backend consumes shared LCU capacity and makes everyone's access logs and metrics harder to read.
  • Cost attribution. An ALB is billed and tagged as one resource, so you lose per-team chargeback.
  • Rule-order coupling. Overlapping paths depend on group order values that every team must coordinate.
  • Debugging. When a request is misrouted, you have to check the merged rule set, which no single team owns.

How do you implement ingress groups safely with IngressClass and IngressClassParams?

Teams should not choose their own alb.ingress.kubernetes.io/group.name annotation. Set the group once on an IngressClassParams object through spec.group.name and reference it from an IngressClass whose controller is ingress.k8s.aws/alb. Every Ingress that uses that class joins the group, and the class-level setting takes precedence over annotations. Add a namespaceSelector to the IngressClassParams so only labeled namespaces can use the class. Without it, any team that can create an Ingress could join a group and add rules that shadow another team's hosts or paths. Both resources are cluster-scoped, so cluster RBAC decides who can create or change them.

Grouping strategy

Define one class per boundary, not one global class:

  • Scheme. Internet-facing and internal traffic always use separate ALBs.
  • Trust or compliance. Workloads that need distinct WAF rules, TLS policies, or audit scope get their own group.
  • Owning team or environment. Production and staging should never share an ALB.

Migration path

  1. Create the grouped Ingresses under the new class. The controller provisions a new ALB with a new DNS name.
  2. Update DNS records deliberately, ideally after lowering TTLs.
  3. Update security group allowlists, WAF associations, and any external health checks or monitors that targeted the old hostname.
  4. Verify routing and error rates on the new ALB.
  5. Remove the old Ingresses. Deleting the last Ingress in a group deletes its ALB, so remove a group's members only when you intend to retire that ALB.

Central defaults also save engineering time. When scheme, tags, and load balancer attributes live in the IngressClassParams, teams stop copying annotations between manifests, and settings no longer drift apart across Ingresses that should behave the same way.

# Cluster-scoped: only platform admins (via cluster RBAC) create or edit these.
apiVersion: elbv2.k8s.aws/v1beta1
kind: IngressClassParams
metadata:
  name: prod-public-payments
spec:
  # Only namespaces carrying this label may use the class.
  namespaceSelector:
    matchLabels:
      alb-group: prod-public-payments
  # One group per boundary: prod + internet-facing + payments team.
  group:
    name: prod-public-payments
  scheme: internet-facing
  # Central defaults replace per-Ingress annotations that tend to drift.
  tags:
    - key: team
      value: payments
    - key: env
      value: prod
  loadBalancerAttributes:
    - key: idle_timeout.timeout_seconds
      value: "60"
---
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: prod-public-payments
spec:
  controller: ingress.k8s.aws/alb
  parameters:
    apiGroup: elbv2.k8s.aws
    kind: IngressClassParams
    name: prod-public-payments
# Teams then set only: spec.ingressClassName: prod-public-payments
# Opt a namespace in:
#   kubectl label namespace payments-api alb-group=prod-public-payments

An IngressClassParams sets the group, scheme, tags and load balancer attributes once and restricts usage to labeled namespaces, and an IngressClass exposes it to teams by name.

How do you find consolidation candidates, and what are the alternatives?

Start with the bill, not the cluster. A Cost and Usage Report with resource IDs enabled breaks ALB spend into hourly charges and LCU charges per load balancer. Any ALB where the hourly line dominates is a consolidation candidate, because you pay that fixed charge whether or not traffic arrives. Confirm with CloudWatch: in the AWS/ApplicationELB namespace, check ConsumedLCUs and RequestCount over a few weeks. Low, flat values usually mean internal tools, staging environments, or low-traffic APIs. Spiky or high values mean usage-driven cost, and merging those ALBs saves little.

Consolidation removes the per-team line item, so plan chargeback before you merge. Each Ingress backend still gets its own target group, and RequestCount is published with a TargetGroup dimension. You can therefore split the shared ALB's cost by request share. ALB access logs record the target group ARN for each request, along with bytes sent and received. That gives you a finer split if bandwidth differs a lot between teams.

Approach Load balancer cost Isolation Ongoing operational cost
One ALB per Ingress Highest; fixed charge per Ingress Full: separate quotas, limits, failure domain Low coordination; many resources to monitor
A few coarse groups (by environment or trust zone) Low Per group Group ownership and rule-priority conventions needed
In-cluster proxy behind one load balancer Lowest AWS spend Shared proxy is a common failure point You run, scale, patch, and upgrade the proxy yourself

The in-cluster proxy moves cost from the AWS bill to engineering time. It only pays off if you already need features the ALB doesn't provide.

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 reduce alb cost 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.
  • Changing a shared variable is one edit and one review instead of editing every service's .env by hand.

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.
  • A wrong or stale value is caught at review time by the services it affects, not by a failed deploy.
  • 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.