A Kubernetes LoadBalancer Service exposes one Service through an external traffic path. An Ingress controller routes HTTP/HTTPS traffic for multiple Services by hostname, path, and TLS rules. Both layers can work together.
The two often work together. An Ingress controller itself commonly needs a public entry path, which may be provided by a load balancer. Raff recommends starting with the traffic requirement first: protocol, routing rules, public endpoint count, TLS ownership, and failure boundary.
Kubernetes Load Balancer vs Ingress: quick answer
| Question | LoadBalancer Service | Ingress controller |
|---|---|---|
| Exposes one Service directly | Yes | Indirectly through routes |
| Best fit for HTTP/HTTPS routing | Limited | Yes |
| Hostname routing | No | Yes |
| Path routing | No | Yes |
| Shared entry for multiple web Services | No | Yes |
| Generic TCP/UDP exposure | Often a strong fit | Not part of standard Ingress API |
| Centralized TLS for several web apps | Provider/workload dependent | Common use case |
| Requires an Ingress controller | No | Yes |
| Can coexist with a load balancer | Yes | Yes — commonly does |
Use a LoadBalancer Service when one workload needs its own external endpoint, especially for TCP, UDP, or a service that does not benefit from shared HTTP routing.
Use an Ingress controller when multiple HTTP/HTTPS Services can share one public entry and need hostname, path, or centralized TLS routing.
Do you need a load balancer with Kubernetes Ingress? Often, yes. The Ingress controller must still be reachable from outside the cluster, so many environments place a load balancer or another edge path in front of it.
For cluster-wide planning, see Kubernetes Networking and Storage Architecture; for Service types, see Kubernetes Services Explained.
Kubernetes LoadBalancer Services provide direct external Service exposure
A Kubernetes Service with type: LoadBalancer requests an external load-balancing implementation from the environment when one is available.
The traffic model is conceptually direct:
Client ↓ External load-balancing path ↓ LoadBalancer Service ↓ Eligible Pods
The Service still represents a changing set of backend Pods. The difference is that the environment can attach an externally reachable address or load-balancing resource to that Service.
This model is useful when one workload genuinely needs its own external endpoint. Common examples include:
- TCP services that are not HTTP-based;
- UDP services where the implementation supports the required protocol;
- one public application that does not need host- or path-based multiplexing;
- a service that benefits from a dedicated traffic boundary;
- workloads whose client protocol does not fit the Ingress API.
A LoadBalancer Service does not provide application-layer routing by hostname or URL path. It exposes Service ports and relies on the load-balancing implementation to deliver traffic to the Service backends.
Kubernetes documents that the exact external load-balancer behavior is implementation-specific. Depending on the environment, the path may involve NodePorts or direct routing.
Ingress controllers consolidate HTTP and HTTPS routing
Ingress solves a different problem. It defines HTTP and HTTPS routing rules to Kubernetes Services.
A typical architecture looks like this:
Internet ↓ Public entry ↓ Ingress controller ↓ Host/path rules ├── app.example.com → web Service ├── api.example.com → api Service └── /admin → admin Service
The backend Services can remain ClusterIP, so they do not each need a public endpoint.
Ingress can provide or coordinate capabilities such as:
- hostname routing;
- path routing;
- TLS termination;
- name-based virtual hosting;
- shared HTTP/HTTPS entry for multiple Services;
- controller-specific traffic features.
An Ingress resource alone does nothing. An Ingress controller must watch those resources and implement the routing behavior.
This is why “load balancer vs ingress controller” can be misleading. In many production clusters, the actual path is:
External load-balancing path ↓ Ingress controller ↓ ClusterIP Services ↓ Pods
The better question is not which component wins. It is which layer should own external exposure and which layer should own HTTP routing.
Ingress controllers can load-balance HTTP traffic
Ingress is a routing API; an Ingress controller enforces those rules and can distribute HTTP traffic across backends.
A Kubernetes Ingress resource is a set of HTTP/HTTPS routing rules. The Ingress controller is the software that implements those rules. That controller may itself perform reverse-proxy and load-balancing behavior across backend Pods, but it still needs a way to receive traffic from outside the cluster.
So the layers are different:
External reachability -> load balancer / public edge HTTP routing -> Ingress controller Backend discovery -> Kubernetes Service Workload -> Pods
Treating these layers separately makes troubleshooting and architecture reviews much clearer.
Load balancers and Ingress controllers solve different traffic problems
| Requirement | LoadBalancer Service | Ingress controller |
|---|---|---|
| Give one Service an external endpoint | Strong fit | Possible through controller routing, but indirect |
| HTTP hostname routing | No native Service feature | Yes |
| HTTP path routing | No native Service feature | Yes |
| Centralized TLS for several web apps | Not by Service routing alone | Common use case |
| Generic TCP exposure | Strong fit where supported | Not part of standard Ingress API |
| Generic UDP exposure | Strong fit where supported | Not part of standard Ingress API |
| Share one web entry across many Services | Poor fit if each Service gets its own endpoint | Strong fit |
| Separate traffic boundary per workload | Strong fit | Requires separate controller/listener design if desired |
| Controller-specific web routing features | No | Yes |
| Works without an Ingress controller | Yes, if LoadBalancer integration exists | No |
Ingress is specifically designed around HTTP and HTTPS. Standard Ingress does not model arbitrary TCP or UDP exposure.
That makes protocol the first architecture decision.
If the client speaks HTTP or HTTPS, shared application-aware routing may be valuable. If the client uses another protocol, a dedicated Service exposure path is often easier to reason about.
Shared Ingress routing reduces public endpoint sprawl
Consider a small SaaS cluster with three web-facing components:
frontend api auth
A dedicated exposure model can look like:
frontend → external endpoint A api → external endpoint B auth → external endpoint C
An Ingress model can instead use:
one public web entry ↓ Ingress controller ├── app.example.com → frontend ├── api.example.com → api └── auth.example.com → auth
This can simplify DNS, TLS, firewall policy, and the list of internet-facing resources.
The trade-off is concentration. The Ingress controller becomes part of the request path for every application routed through it. It must therefore be monitored, sized, replicated when required, and upgraded deliberately.
Consolidation is useful when it removes unnecessary public interfaces. It is harmful when one shared controller becomes an operational dependency that the team does not understand.
Dedicated LoadBalancer Services keep some traffic paths simpler
Ingress is not automatically the simpler option.
A dedicated LoadBalancer Service can be cleaner when one workload needs one external protocol endpoint and there is no benefit from shared HTTP routing.
Examples include:
- a TCP service with its own port;
- a UDP workload where supported;
- a public service that should have an independent lifecycle from the web ingress layer;
- one external application with no hostname/path routing requirement;
- infrastructure where the load-balancing implementation provides a workload-specific capability.
The path is shorter:
Client ↓ LoadBalancer Service ↓ Pods
The cost trade-off is provider-specific. Some environments create a separately billed load balancer for every LoadBalancer Service; others price or implement public entry differently.
Do not assume hyperscaler pricing or topology applies everywhere. Count the actual external resources your cluster creates and verify current platform pricing before using cost as the deciding factor.
TLS ownership changes the design
With Ingress, multiple HTTP/HTTPS applications can commonly terminate TLS at the shared ingress layer:
HTTPS client ↓ Ingress TLS termination ↓ Host/path routing ↓ ClusterIP Service
This can centralize certificate handling and web traffic policy.
A dedicated LoadBalancer Service does not automatically define where TLS terminates. TLS might terminate:
- inside the application Pod;
- at the external load-balancing implementation;
- at another proxy in front of the Service;
- through protocol passthrough to the backend.
The correct choice depends on end-to-end encryption requirements, client certificates, protocol passthrough, and how the team wants to manage certificates.
Ingress controller implementations differ, so review the selected controller's own documentation instead of assuming identical TLS behavior across controllers.
Kubernetes LoadBalancer vs Ingress decision framework
Use these five questions:
| Decision question | Choose a LoadBalancer Service when | Choose an Ingress controller when |
|---|---|---|
| What protocol is exposed? | TCP/UDP or another non-HTTP path | HTTP/HTTPS |
| How many web Services need public access? | One Service with no routing benefit | Several Services can share an entry |
| Is host/path routing required? | No | Yes |
| Should the workload have its own public boundary? | Yes | Not necessarily |
| Where should TLS and web routing policy live? | Workload/provider-specific path | Shared controller layer |
Use this sequence:
- Keep the Service private unless external clients need it. Start with
ClusterIPfor internal workloads. - Identify the protocol. HTTP/HTTPS can use Ingress or Gateway-style routing; non-HTTP protocols may need another exposure model.
- Count the required public entry points. Do not create one per internal Service by habit.
- Choose the routing owner. Decide whether TLS, hostname, and path policy belong in a shared controller or a workload-specific path.
- Define the failure boundary. A shared ingress layer affects several applications; a dedicated endpoint isolates that concern but increases infrastructure count.
The decision is not “which Kubernetes object is better?” It is “which traffic boundary matches the workload?”