How does ALB pricing work, and where does the money go in Kubernetes?

An Application Load Balancer bill has two parts. The first is a fixed hourly charge for every ALB that exists, whether it serves one request or a million. The second is an hourly LCU (Load Balancer Capacity Unit) charge. Each hour, AWS measures four dimensions, converts each into LCUs, and bills only the highest of the four:

  • New connections per second
  • Active connections per minute
  • Processed bytes
  • Rule evaluations per second

The thresholds per LCU and the per-hour prices vary by region and can change, so check the current ELB pricing page.

In Kubernetes, the AWS Load Balancer Controller provisions a separate ALB for each Ingress by default. Teams that create one Ingress per service end up with one fixed charge per service. Consolidation removes fixed charges because there are fewer ALBs. It does little to LCU charges, because the same traffic still flows through a load balancer. Consolidation can also raise the rule-evaluation dimension, since one shared ALB carries every service's listener rules.

Cluster profile Typical ALB count Dominant cost Benefit from consolidation
Many internal or low-traffic services, one Ingress each High Fixed hourly charges Large
Mixed: a few busy APIs plus many small tools Medium Both, roughly comparable Moderate, mostly from the small services
A few high-throughput public endpoints Low LCU usage, usually processed bytes Small

The main lever is to cut the number of idle or near-idle ALBs. Merging busy ALBs saves little, because their cost comes from traffic, and that traffic remains after the merge.

How do you find wasted ALBs in an existing cluster?

Start with an inventory, because it needs no change to manifests or cluster architecture. Clusters that have run for a while often contain ALBs that serve preview environments, forgotten demos, or Ingresses whose traffic moved somewhere else.

Map each ALB to its owner

The AWS Load Balancer Controller tags every ALB it creates. Three tags matter:

  • elbv2.k8s.aws/cluster names the cluster.
  • ingress.k8s.aws/stack contains namespace/ingress-name for a standalone Ingress, or the group name for an IngressGroup.
  • ingress.k8s.aws/resource identifies the resource type.

List the load balancers with aws elbv2 describe-load-balancers. Then fetch their tags with aws elbv2 describe-tags, which accepts up to 20 ARNs per call. Compare each stack tag with kubectl get ingress -A.

Two kinds of mismatch need attention:

  • Orphans. If the stack tag points to an Ingress that no longer exists, the ALB was probably left behind when a namespace or cluster was deleted while the controller wasn't running.
  • Untagged ALBs. These were created outside the controller and need a human owner.

Find idle load balancers

In the AWS/ApplicationELB namespace, pull RequestCount and ConsumedLCUs per LoadBalancer dimension over at least 14 to 30 days. A daily window hides weekly batch jobs.

An ALB that averages near zero on both metrics is billed almost entirely for its hourly charge. That hourly charge is the waste you are looking for.

Also check HealthyHostCount on the attached target groups. An ALB with no healthy targets is serving errors or nothing at all.

Sort the results by request volume. The bottom of the list is your first consolidation or deletion list.

#!/usr/bin/env bash
# Inventory ALBs, map each to its owning Ingress via controller tags,
# and rank by 30-day request volume. Lowest rows = idle candidates.
# Requires: AWS CLI v2, GNU date, read-only ELB + CloudWatch permissions.
set -euo pipefail

END=$(date -u +%Y-%m-%dT%H:%M:%SZ)
START=$(date -u -d '30 days ago' +%Y-%m-%dT%H:%M:%SZ)  # long window catches weekly jobs

aws elbv2 describe-load-balancers \
  --query "LoadBalancers[?Type=='application'].LoadBalancerArn" \
  --output text | tr '\t' '\n' | while read -r ARN; do

  # Owner tags set by the AWS Load Balancer Controller ("None" = not controller-managed)
  read -r CLUSTER STACK < <(aws elbv2 describe-tags --resource-arns "$ARN" \
    --query "TagDescriptions[0].[Tags[?Key=='elbv2.k8s.aws/cluster'].Value|[0], Tags[?Key=='ingress.k8s.aws/stack'].Value|[0]]" \
    --output text)

  # CloudWatch LoadBalancer dimension is the ARN suffix: app/<name>/<id>
  DIM="${ARN#*:loadbalancer/}"

  metric_sum() {
    aws cloudwatch get-metric-statistics --namespace AWS/ApplicationELB \
      --metric-name "$1" --dimensions Name=LoadBalancer,Value="$DIM" \
      --start-time "$START" --end-time "$END" --period 86400 \
      --statistics Sum --query 'sum(Datapoints[].Sum)' --output text
  }

  printf '%s\t%s\t%s\t%s\t%s\n' \
    "$(metric_sum RequestCount)" "$(metric_sum ConsumedLCUs)" \
    "$CLUSTER" "$STACK" "$DIM"
done | sort -n -k1,1 | column -t -s $'\t'

# Next: compare the STACK column (namespace/ingress or group name) against
#   kubectl get ingress -A
# Stacks with no matching Ingress are likely orphans; "None" means no owner tag.

A read-only bash script that lists every ALB with its controller cluster and stack tags plus 30-day RequestCount and ConsumedLCUs totals, sorted so the idle, fixed-cost load balancers appear first.

How does the AWS Load Balancer Controller's IngressGroup feature work?

By default, the AWS Load Balancer Controller provisions one ALB per Ingress object. Ten teams with ten Ingresses get ten ALBs, each billed hourly and each with its own LCU minimum, even when most of them carry very little traffic.

The alb.ingress.kubernetes.io/group.name annotation changes this. Every Ingress carrying the same group name, in any namespace, is reconciled into a single ALB. The controller merges their host and path rules into one set of listener rules and creates a separate target group for each backend Service.

Before: one ALB per Ingress After: one IngressGroup
shop/web → ALB 1 → web target group shop/web ─┐
shop/api → ALB 2 → api target group shop/api ─┼→ one ALB → listener rules → per-service target groups
billing/api → ALB 3 → billing target group billing/api ─┘

ALB listener rules are evaluated in priority order, and the first match wins. alb.ingress.kubernetes.io/group.order controls where each Ingress's rules sit in that order. Lower values are evaluated first, and the default is 0.

Sharing an ALB creates coupling between teams.

  • Silent rule conflicts. If two teams both claim api.example.com/ (the root path on the same host), there is no error. One rule shadows the other, and traffic quietly goes to the wrong service.
  • Group-wide blast radius. Load-balancer-level settings, such as the scheme or TLS configuration, must agree across the group. One Ingress with a conflicting or invalid annotation can block reconciliation for every member.
  • Uncontrolled membership. Anyone who can create an Ingress with the right group name can attach rules to the shared ALB.
# Two Ingresses in different namespaces join one ALB via the same group.name.
# Group-level settings (scheme here) must match across every member.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api
  namespace: shop
  annotations:
    alb.ingress.kubernetes.io/group.name: shared-public
    alb.ingress.kubernetes.io/group.order: "10"   # lower values are evaluated first
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/target-type: ip
spec:
  ingressClassName: alb
  rules:
    - host: shop.example.com        # each team owns a distinct host to avoid shadowing
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service: {name: shop-api, port: {number: 80}}
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api
  namespace: billing
  annotations:
    alb.ingress.kubernetes.io/group.name: shared-public   # same group, same ALB
    alb.ingress.kubernetes.io/group.order: "20"
    alb.ingress.kubernetes.io/scheme: internet-facing     # must agree with shop/api
    alb.ingress.kubernetes.io/target-type: ip
spec:
  ingressClassName: alb
  rules:
    - host: billing.example.com     # reusing shop.example.com here would silently conflict
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service: {name: billing-api, port: {number: 80}}

Two Ingresses in separate namespaces share one ALB through a common group.name, with group.order setting rule priority and distinct hosts preventing silent rule shadowing.

How much can consolidating ALBs actually save? An illustrative estimate

Illustrative estimate (assumed numbers, not a benchmark). The rates below are placeholders. Replace them with current pricing for your region before drawing conclusions.

Assumed inputs:

  • Hourly ALB charge H = $0.02/hour
  • LCU rate L = $0.01/LCU-hour
  • 730 hours/month
  • Cluster A: 30 low-traffic services averaging 0.1 LCU each
  • Cluster B: 5 busy services averaging 40 LCU each

Monthly cost = (number of ALBs × H × 730) + (total LCU × L × 730)

Scenario ALBs Fixed/month LCU/month Total
A, separate 30 $438.00 $21.90 $459.90
A, grouped 3 $43.80 $21.90 $65.70
B, separate 5 $73.00 $1,460.00 $1,533.00
B, grouped 1 $14.60 $1,460.00 $1,474.60

In cluster A, the fixed hourly charge is most of the bill, so consolidation removes most of the cost. In cluster B, the same traffic reaches the same targets whether it uses one ALB or five, so the LCU charge stays the same and the saving is about 4%.

The LCU figure is only roughly constant. Each ALB is billed on its highest LCU dimension. When you merge many host and path rules onto one listener, each request may be checked against more rules before one matches. Rule evaluations beyond the free allowance can then become the dimension that sets the bill. This applies to busy groups with long rule lists.

Before migrating, record ConsumedLCUs, RuleEvaluations, NewConnectionCount, ActiveConnectionCount and ProcessedBytes for every ALB. Compare the totals with the grouped ALBs afterward. If RuleEvaluations grows faster than request volume, reorder or split the rules.

When should you avoid sharing an ALB across services?

Consolidation has costs of its own. These are the cases where a shared ALB causes more trouble than it saves.

Blast radius. The controller reconciles an IngressGroup as a single unit. One malformed annotation, a conflicting path, or a reference to a missing Service in any member Ingress can make reconciliation fail for the whole group. Other teams' route changes then stall until the problem is fixed. Deleting an Ingress, or removing it from the group, also rewrites the shared listener rules, so a careless cleanup can affect routing for unrelated services.

Cross-team coupling. The group name works as a shared namespace. Any team that can create an Ingress with that name can add rules to the ALB. Priority ordering then becomes something teams have to negotiate, because one team's rule can shadow another team's paths.

Load-balancer-level settings. Some settings apply to the whole ALB, so every member of a group must agree on them:

Setting Why it forces separate ALBs
Scheme (internal vs internet-facing) Fixed per ALB
Security groups Apply to every listener and route
WAF web ACL Associated with the whole ALB
Access logs One destination per ALB
Idle timeout One value per ALB
SSL policy Set per listener, shared by all hosts on it

Cost attribution. ALB hours and LCUs are billed per load balancer, so tags can't divide them by team. To apportion the bill, you have to estimate each team's share from per-target-group metrics.

Quotas. Listener rules, target groups, and certificates per listener all have per-ALB limits. When a group reaches one of these limits, the next deploy fails. Check your current limits in Service Quotas before you plan group sizes.

How should you group Ingresses and migrate without downtime?

Start by deciding what a group boundary means. One ALB for the whole cluster minimizes hourly charges but couples every team's deploys, quotas, and security posture. A better default is one group per environment and trust boundary: for example, prod-public, prod-internal, and staging-public. Split further by owning team only when a team's rule count or release cadence would crowd out others.

Conventions that prevent conflicts

Use a predictable group name format, such as <env>-<scheme>[-<team>], and set it with the alb.ingress.kubernetes.io/group.name annotation. Inside a group, the controller merges rules from every member Ingress and orders them using alb.ingress.kubernetes.io/group.order. Reserve order ranges per team or per purpose, and write down which team owns each hostname and path prefix. Without this, two teams can claim the same path, the ALB evaluates whichever rule comes first, and the resulting bug looks like random misrouting. With documented ownership, a reviewer can check a new Ingress against the ownership table instead of reading every other manifest in the group. When something misroutes, the order range points to the responsible team.

Incremental migration

  1. Lower the DNS TTL on the record you are moving well before cutover.
  2. Create a new Ingress with the group annotation alongside the old one. The old ALB keeps serving traffic.
  3. Validate against the shared ALB's DNS name by sending requests with the correct Host header. Check TLS, health checks, and target registration.
  4. Point DNS at the shared ALB. Wait at least one old TTL, then confirm the old ALB's request count has dropped to zero.
  5. Delete the old Ingress so the controller removes its ALB.
  6. List all ALBs in the account and compare them against the Ingresses in your clusters. Any ALB with no matching Ingress is still billing and should be removed.
# New Ingress created alongside the old one during migration.
# The old Ingress (no group annotation) keeps its own ALB until DNS is cut over.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: checkout-grouped        # distinct name so it coexists with the old Ingress
  namespace: checkout
  annotations:
    # Convention: <env>-<scheme>[-<team>]; all members share one ALB
    alb.ingress.kubernetes.io/group.name: prod-public
    # Reserved range for the payments team: 200-299 (see ownership table)
    alb.ingress.kubernetes.io/group.order: "210"
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/target-type: ip
    alb.ingress.kubernetes.io/listen-ports: '[{"HTTPS":443}]'
    # Placeholder ARN; use the certificate that covers this team's hostname
    alb.ingress.kubernetes.io/certificate-arn: arn:aws:acm:us-east-1:111122223333:certificate/example-id
spec:
  ingressClassName: alb
  rules:
    # Owned by payments: host checkout.example.com, all paths under /
    - host: checkout.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: checkout-web
                port:
                  number: 80
# Before DNS cutover, test against the shared ALB with the right Host header:
#   curl -sv https://<shared-alb-dns-name>/ -H 'Host: checkout.example.com' -k
# (-k only because the ALB DNS name does not match the certificate.)
# After DNS cutover and one old TTL with zero requests on the old ALB:
#   kubectl delete ingress checkout-legacy -n checkout

A grouped Ingress that joins the shared prod-public ALB, using the naming convention, a reserved group.order range and an owned hostname, created alongside the legacy Ingress so it can be validated before DNS cutover and before the old Ingress is deleted.

What are the alternatives to IngressGroups for cutting load balancer costs?

IngressGroups are not the only way to cut the number of billed load balancers. There are two other common approaches:

  • Delete idle ALBs. This needs no architectural change and should be done whichever option you choose.
  • Run your own proxy inside the cluster. You put one ALB or NLB in front of an in-cluster ingress proxy, and the proxy does all host and path routing. The cloud load balancer becomes a thin entry point, so you pay one fixed hourly charge per cluster no matter how many services you expose.
Option Load balancers billed Who handles TLS, routing, scaling Operational cost
Delete idle ALBs One per active Ingress AWS Minimal; a recurring audit
IngressGroups One per group AWS Low; group naming and rule-ordering discipline
Single ALB/NLB + in-cluster proxy One per cluster (or per proxy tier) Your team High; proxy upgrades, autoscaling, certificate rotation, on-call

The in-cluster proxy can save the most, but it moves work onto your team.

  • TLS termination moves into the cluster. Your team now handles it, including certificate storage and renewal.
  • Proxy pods are on the request path. A bad config push or pods starved of CPU take down every service at once.
  • You own capacity planning. With AWS-managed routing, AWS absorbs traffic spikes. With your own proxy, you have to size and autoscale those pods yourself.
  • The ALB or NLB still bills for capacity. Throughput moves from ALB LCUs to NLB NLCUs or to the proxy's compute, so traffic costs do not disappear.

How to choose:

  • Proxy: Pick it if you have dozens of low-traffic services and a platform team that already runs cluster add-ons reliably.
  • IngressGroups: Pick them if you have a handful of busy services or a small team. They capture most of the savings while AWS keeps operating the data path.
  • Delete idle ALBs: Do this regardless of which option you choose.

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 costs kubernetes, 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.