How does ALB pricing work: hourly charges and LCUs
Every ALB has two cost components. The first is a fixed hourly charge that applies whether the load balancer serves a million requests or none. The second is a usage charge measured in Load Balancer Capacity Units (LCUs). Rates vary by region and change over time, so check the AWS Elastic Load Balancing pricing page for current numbers rather than relying on figures copied into a runbook.
An LCU is not one metric. AWS measures four dimensions, works out how many LCUs each one would require for the hour, and bills only the highest. You pay for your bottleneck dimension, not the sum of all four.
| Dimension | What one LCU covers (per AWS documentation) | Typical driver |
|---|---|---|
| New connections | 25 new connections per second | Short-lived clients, no keep-alive |
| Active connections | 3,000 active connections per minute | WebSockets, long polling |
| Processed bytes | 1 GB per hour (EC2/IP targets) | Large payloads, file transfer |
| Rule evaluations | 1,000 rule evaluations per second | Many listener rules × request rate |
Confirm these thresholds on the pricing page, because AWS defines them there.
Why rule count matters
The first 10 rule evaluations per request are free. Beyond that, billable evaluations are roughly (rules processed − 10) × requests per second. Rule count and traffic multiply, which is why this dimension matters most for consolidation. Illustrative estimate: a listener that evaluates 40 rules per request at 200 requests per second produces (40 − 10) × 200 = 6,000 evaluations per second. That is 6 LCUs on this dimension alone, which may exceed what the same traffic generates in bytes or connections.
Rule ordering also changes the bill. Rules are evaluated in priority order until one matches, so placing high-traffic routes early keeps the average rules processed per request low.
How does consolidating behind a shared ALB work?
An ALB is not tied to a single application. It is a container for listeners, and each listener holds an ordered list of rules. Each rule has conditions and an action. Consolidation uses this structure to route many services through one load balancer:
- Listeners accept traffic on a port and protocol, typically one HTTPS listener on 443 and optionally an HTTP listener on 80 that redirects to HTTPS. All services share these listeners.
- Rules match on request attributes, most commonly
host-header(which hostname the client asked for) andpath-pattern(which URL path). Other condition types include HTTP headers, HTTP methods, query strings, and source IP. The ALB evaluates rules in ascending priority order and applies the first match. - Target groups hold the backends for one service: instances, IP addresses, or Lambda functions, each with its own health check. A matching rule forwards the request to that service's target group.
- Certificates for every hostname live on the shared HTTPS listener. During the TLS handshake the client sends the hostname it wants through SNI, and the ALB picks the matching certificate.
- DNS for each service hostname points at the shared ALB's DNS name, usually through an alias or CNAME record. From the client's point of view nothing changes except the address the name resolves to.
A request for billing.example.com/api/invoices therefore resolves to the shared ALB, completes TLS with the billing certificate, walks the rule list until the billing host rule matches, and is forwarded to the billing target group. Services stay isolated at the target group and health check level while sharing the load balancer, its listeners, and its fixed hourly charge.
On EKS, the AWS Load Balancer Controller builds this structure for you from Ingress resources. Outside Kubernetes, you create the rules and target groups yourself with the CLI or infrastructure-as-code. Both approaches are covered below.
Why do many low-traffic ALBs cost more than one shared ALB?
Each ALB carries a fixed hourly charge whether it serves one request a minute or thousands a second. A low-traffic service uses a fraction of an LCU, so most of its load balancer bill is that fixed charge. Ten such services behind ten ALBs pay the fixed charge ten times for traffic one ALB could carry.
Consolidation removes N−1 hourly charges. Traffic doesn't change, so the bytes, connections and requests just add up on the shared ALB. LCU usage stays roughly flat and may drop slightly, because each hour is billed on the highest dimension, and the maximum of a sum is never larger than the sum of the maximums.
Illustrative estimate (assumed numbers, not a benchmark). Assume N = 12 ALBs, hourly rate H = $0.02, LCU rate L = $0.008 per LCU-hour, 0.2 LCU per service, and 730 hours per month.
- Monthly cost = (ALB count × H + total LCU × L) × 730
- Savings ≈ (N − 1) × H × 730
| Setup | Total LCU | Monthly cost |
|---|---|---|
| 12 separate ALBs | 2.4 | (12×0.02 + 2.4×0.008) × 730 ≈ $189 |
| 1 shared ALB, small rule set | 2.4 | (0.02 + 2.4×0.008) × 730 ≈ $29 |
| 1 shared ALB, 60 rules | 9.0 | (0.02 + 9×0.008) × 730 ≈ $67 |
The savings grow with ALB count, not with traffic.
The last row shows the catch. The first 10 rules evaluated per request are free. Assume 300 req/s combined, with requests matching after 40 rules on average. That is 300 × (40 − 10) = 9,000 rule evaluations per second, or 9 LCU. Rule evaluations now set the bill and cut the savings from about $160 to about $122 per month.
Which ALBs are good consolidation candidates?
Start with an inventory. aws elbv2 describe-load-balancers returns every load balancer in a region with its ARN, scheme, VPC, and security groups. Run it per region, and filter on Type because the same command also lists Network and Gateway Load Balancers.
For each ALB, pull two weeks of daily totals with aws cloudwatch get-metric-statistics. Use the AWS/ApplicationELB namespace, the LoadBalancer dimension (the app/name/id suffix of the ARN), a period of 86400, and the Sum statistic. Do this for both RequestCount and ConsumedLCUs. Choose a window that covers weekly peaks and batch jobs, because an ALB that looks idle on Tuesday may carry month-end traffic.
Then cross-check the Cost and Usage Report. Each ALB bills hourly usage and LCU usage as separate line items. Compare the two for every ALB:
- Strong candidates: ALBs where the hourly charge dominates and LCU charges are a rounding error.
- Leave alone: ALBs where LCU spend exceeds the hourly fee. Merging these mostly moves LCUs around rather than eliminating them. It can also add rule-evaluation cost, as the previous example showed.
Among the idle and near-idle ALBs, group only those that already share the properties a single ALB enforces:
- Scheme and VPC: internet-facing and internal ALBs cannot be merged.
- Security groups: merging widens ingress to the union of the existing rules.
- WAF web ACL: an ALB has at most one web ACL.
- Idle timeout and other load balancer attributes: these apply to the whole ALB.
- Environment: keep production and non-production apart, so a bad listener rule change in staging cannot reach production.
#!/usr/bin/env bash
set -euo pipefail
REGIONS="${REGIONS:-us-east-1 eu-west-1}" # Set to the regions you actually use
DAYS=14 # Long enough to cover weekly peaks and batch jobs
END=$(date -u +%Y-%m-%dT00:00:00Z)
START=$(date -u -d "-${DAYS} days" +%Y-%m-%dT00:00:00Z)
printf 'region\tname\tscheme\tvpc\trequests_%sd\tlcus_%sd\n' "$DAYS" "$DAYS"
for region in $REGIONS; do
# describe-load-balancers also returns NLBs and GWLBs, so keep only Type == application
aws elbv2 describe-load-balancers --region "$region" \
--query "LoadBalancers[?Type=='application'].[LoadBalancerName,LoadBalancerArn,Scheme,VpcId]" \
--output text |
while read -r name arn scheme vpc; do
# CloudWatch dimension is the ARN suffix after 'loadbalancer/', e.g. app/orders-api/50dc6c495c0c9188
dim="${arn#*:loadbalancer/}"
totals=()
for metric in RequestCount ConsumedLCUs; do
# Daily Sum datapoints, added together; JMESPath sum([]) yields 0 for idle ALBs
total=$(aws cloudwatch get-metric-statistics --region "$region" \
--namespace AWS/ApplicationELB --metric-name "$metric" \
--dimensions Name=LoadBalancer,Value="$dim" \
--start-time "$START" --end-time "$END" \
--period 86400 --statistics Sum \
--query 'sum(Datapoints[].Sum)' --output text)
totals+=("$total")
done
printf '%s\t%s\t%s\t%s\t%s\t%s\n' "$region" "$name" "$scheme" "$vpc" "${totals[0]}" "${totals[1]}"
done
done | sort -t$'\t' -k6,6g # Lowest LCU consumption first: likely consolidation candidates
A read-only Bash script that lists Application Load Balancers per region and sums 14 days of RequestCount and ConsumedLCUs from CloudWatch, sorted so idle and near-idle ALBs appear first for cross-checking against the Cost and Usage Report.
How do you consolidate ALBs on EKS with an ingress group?
With the AWS Load Balancer Controller, each Ingress gets its own ALB by default. Adding the annotation alb.ingress.kubernetes.io/group.name changes that: every Ingress with the same group name is merged into one ALB, and the controller combines their rules into a single set of listener rules. Two teams can keep separate Ingress manifests in their own namespaces, for example orders and billing, both set to group.name: shared-prod. Each team still owns its routes, but neither pays for a dedicated ALB.
The resulting traffic flow:
orders.example.com/api/*→ listener rule →orders-apitarget grouporders.example.com/*→ listener rule →orders-webtarget groupbilling.example.com/*→ listener rule →billingtarget group
All three flows pass through the same ALB and HTTPS listener.
ALB listener rules are evaluated in priority order, and the first match wins. Use alb.ingress.kubernetes.io/group.order to control which Ingress's rules are evaluated first. Lower values go first. Give specific paths a lower order than catch-alls. Otherwise one team's /* can capture another team's traffic on a shared host.
Avoiding recreated or orphaned ALBs
The group name determines the ALB's identity. If you rename the group or remove the annotation, the controller creates a new load balancer with a new DNS name. When the last Ingress leaves the old group, the controller deletes the old ALB. To avoid this:
- Treat the group name as immutable.
- Set it centrally through
IngressClassParamsso teams cannot change it. - Keep group-wide settings such as scheme, subnets, and load balancer attributes identical across all members. Conflicting values block reconciliation.
- Enable
deletion_protection.enabled=trueso that deleting a single Ingress cannot remove the shared ALB.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: orders
namespace: orders
annotations:
alb.ingress.kubernetes.io/group.name: shared-prod # ALB identity: never rename
alb.ingress.kubernetes.io/group.order: "10"
# Group-wide settings: keep identical in every member Ingress
alb.ingress.kubernetes.io/scheme: internet-facing
alb.ingress.kubernetes.io/listen-ports: '[{"HTTPS":443}]'
alb.ingress.kubernetes.io/load-balancer-attributes: deletion_protection.enabled=true
alb.ingress.kubernetes.io/target-type: ip
spec:
ingressClassName: alb
rules:
- host: orders.example.com
http:
paths: # specific path listed before the catch-all
- {path: /api, pathType: Prefix, backend: {service: {name: orders-api, port: {number: 80}}}}
- {path: /, pathType: Prefix, backend: {service: {name: orders-web, port: {number: 80}}}}
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: billing
namespace: billing
annotations:
alb.ingress.kubernetes.io/group.name: shared-prod
alb.ingress.kubernetes.io/group.order: "20"
alb.ingress.kubernetes.io/scheme: internet-facing
alb.ingress.kubernetes.io/listen-ports: '[{"HTTPS":443}]'
alb.ingress.kubernetes.io/load-balancer-attributes: deletion_protection.enabled=true
alb.ingress.kubernetes.io/target-type: ip
spec:
ingressClassName: alb
rules:
- host: billing.example.com
http:
paths:
- {path: /, pathType: Prefix, backend: {service: {name: billing, port: {number: 80}}}}
Two Ingresses in separate namespaces join the shared-prod group, so they share one ALB. group.order sets their rule priority, and the group-wide settings, including deletion protection, are identical in both manifests.
How do you share one ALB outside Kubernetes?
Without a controller, you build the same structure explicitly. Each service gets its own target group, and the shared HTTPS listener gets one rule per service. A rule matches on host-header (for example billing.example.com), path-pattern (for example /api/orders/*), or both, and forwards to that service's target group. Rules are evaluated in ascending priority order, so leave gaps between priority numbers to make room for later inserts. Point the listener's default action at a fixed 404 response rather than at a real service, so unmatched traffic fails visibly instead of reaching the wrong backend.
With the AWS CLI, you add a rule with aws elbv2 create-rule, which takes the listener ARN, a priority, --conditions, and a forward action. In Terraform, the equivalent is an aws_lb_listener_rule resource per service. For TLS, a single HTTPS listener can hold several certificates. The ALB uses SNI to select the certificate that matches the client's requested hostname and falls back to the listener's default certificate when nothing matches. You attach extra certificates with aws elbv2 add-listener-certificates or the aws_lb_listener_certificate resource.
Rules per ALB, target groups per ALB, and certificates per ALB all have quotas, and some of them are adjustable. Don't copy limits from blog posts. Check the current values in the Service Quotas console under Elastic Load Balancing, or run aws service-quotas list-service-quotas --service-code elasticloadbalancing.
Plan shards along boundaries that already exist in your organization, such as one ALB per environment or one per apex domain. That keeps each shard well under its quotas and limits the blast radius of a bad rule change.
#!/usr/bin/env bash
set -euo pipefail
LISTENER_ARN="arn:aws:elasticloadbalancing:us-east-1:111122223333:listener/app/shared-prod/abc123/def456"
BILLING_TG_ARN="arn:aws:elasticloadbalancing:us-east-1:111122223333:targetgroup/billing-prod/0123456789abcdef"
BILLING_CERT_ARN="arn:aws:acm:us-east-1:111122223333:certificate/11111111-2222-3333-4444-555555555555"
aws elbv2 modify-listener \
--listener-arn "$LISTENER_ARN" \
--default-actions '[{"Type":"fixed-response","FixedResponseConfig":{"StatusCode":"404","ContentType":"text/plain","MessageBody":"no route"}}]'
aws elbv2 create-rule \
--listener-arn "$LISTENER_ARN" \
--priority 200 \
--conditions '[{"Field":"host-header","HostHeaderConfig":{"Values":["billing.example.com"]}},{"Field":"path-pattern","PathPatternConfig":{"Values":["/api/*"]}}]' \
--actions "[{\"Type\":\"forward\",\"TargetGroupArn\":\"$BILLING_TG_ARN\"}]"
aws elbv2 add-listener-certificates \
--listener-arn "$LISTENER_ARN" \
--certificates CertificateArn="$BILLING_CERT_ARN"
aws service-quotas list-service-quotas \
--service-code elasticloadbalancing \
--query 'Quotas[].[QuotaName,Value,Adjustable]' \
--output table
AWS CLI commands that set a 404 default action on a shared ALB listener, add a host-header and path-pattern rule that forwards to one service's target group, attach an extra SNI certificate, and list the account's current Elastic Load Balancing quotas.
When should you avoid consolidating ALBs?
Consolidation trades money for coupling, and the coupling is not always worth it.
Blast radius grows with every service you add. A malformed listener rule, an accidental change to the default action, or a deleted certificate that the HTTPS listener still references affects every hostname on that ALB at once. With separate ALBs, the same mistake breaks one service.
Multi-team ingress groups need guardrails. Any Ingress that joins a group can add rules to the shared listener. Rules are evaluated in priority order, so a team that claims an overlapping host or path, or sets a lower group.order, can shadow another team's routes. The ALB accepts this without error and simply sends traffic to the wrong target group. Use admission policies or strict naming conventions that reserve hostnames per team, and reject Ingresses that set order values outside a team's assigned range.
Per-ALB settings become shared. Idle timeout, security groups, WAF web ACL, access log destination, deletion protection, and scheme (internal or internet-facing) apply to the whole load balancer. A service that needs a long idle timeout or a stricter WAF rule set forces that choice on everyone else on the ALB.
High-traffic services gain little. Their bill is dominated by LCUs, which consolidation does not reduce. Merging them also removes per-ALB cost visibility. Attribution then relies on target group metrics or parsing access logs.
| Option | Cost | Blast radius | Config isolation |
|---|---|---|---|
| One ALB per service | Highest fixed cost | Smallest | Full |
| Sharded shared ALBs | Moderate | Per shard | Per shard |
| Single global ALB | Lowest | Everything | None |
| In-cluster ingress/gateway behind one LB | Low, plus proxy compute | Everything behind the proxy | Handled in the proxy layer |
What are the alternatives to consolidating ALBs?
Consolidation is one way to cut fixed load balancer cost. Depending on why the ALBs exist, one of these may fit better or work alongside it:
-
Delete ALBs that serve nothing. The inventory often turns up load balancers left behind by deleted stacks, finished experiments, or renamed ingress groups. Deleting an orphaned ALB removes its hourly charge with no routing changes and no shared-infrastructure risk. Do this before planning any consolidation.
-
Tear down non-production ALBs outside working hours. An ALB cannot be stopped; it bills for every hour it exists. If dev or preview environments are defined in infrastructure-as-code, you can destroy and recreate them on a schedule. The trade-off is a new DNS name on each recreation unless DNS is updated as part of the pipeline, plus the time to recreate the stack.
-
Run an in-cluster ingress controller or Gateway API implementation behind one load balancer. On Kubernetes, a reverse proxy running as pods can handle host and path routing for every service, fronted by a single ALB or NLB. This keeps the ALB rule count low, avoiding rule-evaluation LCUs, and gives you routing features the ALB does not offer. You pay for the proxy pods' compute and take on operating, scaling, and patching the proxy yourself.
-
Use a Network Load Balancer where Layer 7 features aren't needed. For TCP or TLS-passthrough services that don't use host or path routing, an NLB may suit the workload better. NLBs have their own hourly and capacity-unit pricing, so compare current rates on the pricing page for your traffic profile rather than assuming one is cheaper.
-
Route low-traffic HTTP functions through Amazon API Gateway. For services that are already Lambda functions with occasional traffic, API Gateway bills per request instead of per hour. At low request volumes this can cost less than any always-on load balancer. At sustained high volume the comparison can reverse, so model it with your own request counts.
-
Keep dedicated ALBs and accept the cost. For high-traffic, compliance-sensitive, or independently owned services, the isolation of one ALB per service can be worth more than the hourly charge it costs.
What is a safe migration plan to a shared ALB?
-
Build the shared ALB before moving anything. Create the listeners, attach every certificate the migrating hostnames will need (ALB selects the right one via SNI), enable access logs, and set the default rule to a fixed 404. Because the default rule is a 404, an unmatched host fails visibly instead of landing on the wrong service.
-
Move one service at a time, lowest risk first. Create its target group and copy the old health check exactly: path, port, success codes, interval and thresholds. If the checks differ, targets that are healthy on the old ALB can show as unhealthy on the new one. Confirm all targets are healthy before any traffic moves.
-
Shift traffic gradually. Use weighted DNS records to send a small share of requests to the new ALB. Compare 5xx rates and latency per target group, then raise the weight. If you prefer a hard cutover, lower the record's TTL well in advance so you can roll back quickly.
-
Verify the details that are easy to miss. Check that each hostname presents the correct certificate, that access log entries arrive for the new host rules, and that WAF associations, idle timeouts and stickiness settings carried over.
-
Decommission and confirm. Wait until the old ALB's request count reaches zero, since DNS caches lag. Then remove its deletion protection and delete the ALB and its target groups. List load balancers in every region afterward. An idle ALB still bills every hour.
How can consolidation save engineering time?
The ongoing savings are in engineering time as well as on the bill. You end up with fewer load balancers, DNS records and certificates to renew, audit and monitor. Onboarding a new service becomes a repeatable pattern: add a target group and a host rule instead of provisioning a new stack.
Concretely, a shared ALB cuts recurring work in several places:
-
Onboarding. A new service needs a target group, a listener rule, a DNS record, and possibly a certificate added to an existing listener. On EKS it needs only an Ingress with the agreed group name. There is no new load balancer, security group, access log configuration, or WAF association to set up and review.
-
Security and compliance review. TLS policy, WAF web ACL, security groups, and access logging are configured once per shared ALB instead of once per service. Auditors and reviewers check a handful of load balancers rather than every one in the account, and a policy change such as moving to a stricter TLS security policy is a single update per shard.
-
Monitoring and alerting. Load-balancer-level dashboards and alarms, such as 5xx counts, rejected connections, and unhealthy host counts, are defined per shared ALB. Per-service visibility comes from target group metrics on the same load balancer, so there are fewer alarm definitions to keep in sync.
-
Cost investigation. With fewer ALBs, the load balancer section of the Cost and Usage Report is shorter and easier to explain, and orphaned load balancers stand out instead of hiding among dozens of similar line items.
-
Infrastructure-as-code maintenance. A shared ALB module with per-service rule resources is less code to upgrade and review than a full load balancer stack duplicated in every service repository.
Illustrative estimate (assumed inputs, not a measurement). Assume a team runs 12 dedicated ALBs and spends an assumed 30 minutes per ALB per quarter on certificate checks, security group reviews, and alarm maintenance. That is 6 hours per quarter. Consolidated onto 2 shards with the same assumed per-ALB effort, it falls to 1 hour per quarter, plus whatever time listener rule reviews add. Substitute your own per-ALB effort; the point is that this work scales with the number of load balancers, not with the number of services.
The trade-off is that changes to a shared ALB need more care, because they affect every service on it. Guardrails such as admission policies, reserved hostnames, and reviewed rule changes cost some time up front, and that time should be counted against the savings.
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 aws alb costs, 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
.envby 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.