Kubernetes Services Explained: Ingress and Load Balancers

Serdar Tekin
Serdar Tekin
Co-Founder & CTO
Updated Nov 17, 202616 min read
Written for: Developers and platform teams choosing Kubernetes Service types and traffic exposure patterns.
KubernetesServicesClusterIPNodePortLoadBalancerGateway APIIngress
Last reviewed:
Guide
Kubernetes Services Explained: Ingress and Load Balancers
rafftechnologies.com/learn
On this page

Key Takeaways

Use ClusterIP for internal services, Gateway API or Ingress for shared routing, and LoadBalancer for deliberate dedicated public endpoints.

Free control plane

Route traffic to your services on managed Kubernetes.

CNCF-certified Kubernetes with a free control plane. Add nodes when you need them, with no egress fees.

Kubernetes Services give changing Pods a stable network identity. They solve service discovery and reachability; external exposure is a separate decision handled through Service types such as LoadBalancer, or through routing APIs such as Gateway API and Ingress.

For small teams, the useful model is:

Traffic path 1: Client Pod → ClusterIP Service → Pods

Traffic path 2: Internet → Gateway / Ingress → ClusterIP Service → Pods

Traffic path 3: Internet → LoadBalancer Service → Pods

Raff Technologies uses the same separation in its managed Kubernetes platform: cluster infrastructure stays on private networking, while application teams choose which Services and routes should be public.

This guide owns the Kubernetes Service and exposure model: ClusterIP, NodePort, LoadBalancer, ExternalName, and where Gateway API or Ingress fits above Services. For the narrower decision between a dedicated load balancer and shared application routing, use Kubernetes Load Balancer vs Ingress Controller. For hands-on configuration, the dedicated ingress tutorial should own implementation steps rather than duplicating them here.

What is a Kubernetes Service?

Pods are replaceable. Deployments create new Pods, failed Pods disappear, autoscaling changes replica counts, and the scheduler can move workloads between nodes.

A Kubernetes Service gives clients a stable network identity while the backing Pods change.

Client → Service → EndpointSlices → Pod A / Pod B / Pod C

Kubernetes maintains EndpointSlice information for the endpoints behind a Service. Clients can therefore use the Service rather than tracking individual Pod IP addresses.

If a Service name does not resolve, or resolves but traffic still fails, use Kubernetes DNS and Service Discovery Troubleshooting to separate namespace and resolver problems from EndpointSlice, CoreDNS, NetworkPolicy, and application-connectivity failures.

A Service is useful when another workload or traffic path needs a stable destination. A background worker that never accepts inbound traffic may not need a Service at all.

The important distinction is:

  • Pods are workload instances.
  • Services are stable workload identities.
  • Gateway API, Ingress, or LoadBalancer exposure determines how outside traffic reaches a Service.

Kubernetes Service types: ClusterIP, NodePort, LoadBalancer, and ExternalName

The main Kubernetes Service types solve different reachability problems.

Service typeWhat it doesTypical production use
ClusterIPGives the Service an internal cluster addressInternal APIs, backends, caches, private application services
NodePortOpens the Service on a port on each nodeLower-level building block or special network integration
LoadBalancerRequests an external load-balancing path when the environment supports itDedicated public endpoint, TCP/UDP exposure, simple single-service public entry
ExternalNameReturns an external DNS name through cluster DNSNaming an external dependency through a Kubernetes Service name

These types are not a maturity ladder. A production application does not become "more Kubernetes" by moving from ClusterIP to NodePort or LoadBalancer.

The correct Service type follows from who needs to reach the workload and from where.

ClusterIP should be the default for internal workloads

ClusterIP is the default Service type and is the normal starting point for service-to-service traffic inside the cluster.

Typical examples include:

  • private APIs;
  • internal web backends;
  • caches;
  • queues with cluster-only consumers;
  • admin services reachable only through another controlled layer;
  • application components behind a public Gateway or Ingress.

A common production pattern is:

Internet → Gateway / Ingress → ClusterIP Service → Application Pods

The application is public, but the Service itself remains internal.

This is usually easier to reason about than giving every web workload its own public endpoint.

NodePort is a building block, not the default public architecture

A NodePort Service exposes the Service on a port across cluster nodes.

Conceptually:

client → node-ip:nodePort → Service → Pods

NodePort can be useful when:

  • an external load balancer needs to forward traffic to node ports;
  • a specific infrastructure integration depends on node-level access;
  • a temporary or controlled environment needs simple node-based exposure.

For most small-team production applications, directly publishing NodePorts is not the cleanest application entry model. It widens the set of node addresses and ports that participate in the traffic path and usually lacks the application-routing features teams expect for HTTP services.

Use NodePort because a named architecture requires it, not because it is the next Service type after ClusterIP.

LoadBalancer gives one Service a dedicated external entry point

A Service with type LoadBalancer asks the Kubernetes environment to provide an external traffic path for that Service.

Internet → external load-balancing path → LoadBalancer Service → Pods

This is a strong fit when:

  • one workload needs its own public endpoint;
  • the protocol is TCP or UDP rather than HTTP/HTTPS routing;
  • hostname or path multiplexing is not useful;
  • the platform can provide the external load-balancing integration cleanly.

It becomes less attractive when many HTTP applications each get an independent public load balancer even though they could share one application-routing layer.

That narrower decision belongs in Kubernetes Load Balancer vs Ingress Controller.

Gateway API and Ingress sit above Services

For application traffic such as HTTP and HTTPS, Kubernetes supports routing resources that sit above Services.

Today, Gateway API is the forward-looking Kubernetes traffic-routing model. The Kubernetes project describes Gateway API as the successor to Ingress and recommends Gateway instead of Ingress for new functionality. Ingress remains stable and supported, but its API is frozen.

A Gateway API path can look like:

Internet → Gateway → HTTPRoute / GRPCRoute → ClusterIP Service → Pods

An Ingress path commonly looks like:

Internet → Ingress controller → Ingress rule → ClusterIP Service → Pods

The key point is that neither Gateway nor Ingress replaces a Service. They route traffic to Services.

For a new architecture, Gateway API is worth evaluating when the chosen Kubernetes implementation and controller support it. Existing Ingress deployments do not need to be replaced only because Gateway API exists.

When should you use Gateway API instead of Ingress?

Use Gateway API as the starting point when:

  • you are designing a new cluster traffic model;
  • your platform supports the Gateway API resources you need;
  • infrastructure and application teams should own different parts of the routing configuration;
  • you need richer portable routing such as multiple route types or more expressive traffic control.

Continue using Ingress when:

  • it already serves the workload reliably;
  • your controller and operational tooling are built around Ingress;
  • Gateway API support in your chosen environment does not yet cover the required feature set;
  • a migration would add risk without solving a current requirement.

Gateway API is not a reason to rewrite a stable production traffic layer without a benefit.

Ingress still matters, but its role should be explicit

Ingress remains common in production and supports HTTP/HTTPS routing to Services through rules such as hosts and paths.

For example:

app.example.com → app Service

api.example.com → api Service

example.com/admin → admin Service

An Ingress resource needs an Ingress controller to implement those rules. Creating an Ingress object alone does not provide the traffic path.

A shared Ingress layer can be useful when several HTTP applications should use one external entry architecture rather than separate public endpoints.

The implementation details—controller selection, DNS, TLS, host routing, verification, and rollback—should live in the dedicated Configure Kubernetes Ingress tutorial, not in this architecture page.

Service type and protocol should be chosen together

A simple decision flow is:

RequirementStart with
Only workloads inside the cluster should reach itClusterIP
Several HTTP/HTTPS apps need shared host/path routingGateway API or Ingress → ClusterIP Services
One workload needs a dedicated public TCP/UDP endpointLoadBalancer Service
Existing infrastructure explicitly expects a node portNodePort
Application should refer to an external DNS dependency through cluster DNSExternalName

The most important question is not "Which Kubernetes object is best?" It is:

What traffic path does this workload actually need?

If the answer is private cluster traffic, keep the Service private.

Services do not define traffic authorization

A Service makes a workload reachable. It does not decide whether every source should be allowed to use that path.

Traffic authorization and isolation are separate responsibilities.

A production model can combine:

private VPC → Gateway / Ingress → ClusterIP Service → NetworkPolicy → Pods

The layers solve different problems:

  • VPC: infrastructure network boundary;
  • Service: stable workload identity;
  • Gateway/Ingress: application traffic routing;
  • NetworkPolicy: permitted Pod traffic when enforced by the cluster network;
  • application auth: user and service authorization.

Use Kubernetes Network Policies for Small Teams for the isolation layer.

Health and readiness determine whether a Service should send traffic to a Pod

A stable Service does not guarantee that every backing Pod is ready to receive requests.

Production workloads should use readiness behavior so unhealthy or still-starting Pods are not treated as ready endpoints.

The application traffic model should therefore be reviewed as:

client → routing layer → Service → ready endpoints → Pods

This matters during:

  • application startup;
  • rolling deployments;
  • node maintenance;
  • dependency failures;
  • configuration errors.

A routing design is only as reliable as the workload health signals behind it.

How this maps to Raff Kubernetes

Raff Kubernetes provides the infrastructure underneath these Kubernetes traffic choices.

The current managed Kubernetes product includes:

  • a $0 standard control plane;
  • optional three-master HA for $30/month;
  • private networking for cluster nodes;
  • a managed public endpoint with automatic DNS and TLS;
  • node pools and autoscaling;
  • built-in monitoring and pod logs;
  • dedicated storage nodes priced at $0.10/GB-month;
  • unmetered public bandwidth up to 3 Gbps with $0 egress fees.

Those features do not change the Kubernetes responsibility model.

Your application still decides:

  • which workloads need a Service;
  • which Services remain private;
  • whether public HTTP traffic uses Gateway API or Ingress;
  • whether a workload needs a dedicated LoadBalancer Service;
  • which traffic should be restricted through NetworkPolicy;
  • how health and readiness determine eligible endpoints.

Use the Raff Kubernetes product page as the live source for current platform scope and pricing.

Production traffic review checklist

Before exposing a Kubernetes workload, verify:

Service identity

  • The workload actually needs a Service.
  • Selectors target the intended Pods.
  • Readiness prevents traffic reaching unready Pods.
  • Clients depend on the Service name, not Pod IPs.

Exposure

  • Internal workloads remain ClusterIP unless a public requirement exists.
  • NodePort is used only for a named infrastructure reason.
  • LoadBalancer Services are deliberate public endpoints.
  • Gateway API or Ingress is used when shared application routing is the better model.
  • The public endpoint count is intentional.

Security

  • VPC/firewall boundaries are separate from Kubernetes Service design.
  • NetworkPolicy enforcement is confirmed before relying on policies.
  • TLS termination ownership is clear.
  • Application authentication and authorization remain above the network layer.

Operations

  • The team knows which controller implements Gateway or Ingress.
  • DNS ownership is clear.
  • Controller or load-balancer failure is part of the availability model.
  • Traffic behavior during rolling updates has been tested.

The default small-team pattern

For most web applications operated by a small team, start with:

private worker nodes → ClusterIP Services → application Pods

public traffic → Gateway API or existing Ingress → only the Services that must be public

Use a LoadBalancer Service when a workload genuinely needs its own external endpoint, particularly for non-HTTP traffic or a simple dedicated service path.

That keeps the cluster's public surface smaller and preserves a clear separation between service discovery and external routing.

Continue with Kubernetes Networking and Storage Architecture for the broader network boundary, Kubernetes Load Balancer vs Ingress Controller for the exposure decision, and Kubernetes Network Policies for east-west traffic isolation.

Deploy Raff Kubernetes with private cluster networking and expose only the application traffic paths your workloads need.

Free control plane · 14-day money-back guarantee

Deploy a Cluster Now
Was this article helpful?
Serdar Tekin
Serdar Tekin
Co-Founder & CTO

Co-Founder & CTO at Raff, focused on cloud infrastructure, systems architecture, security, reliability, and production operations.

Free control plane

Route traffic to your services on managed Kubernetes.

CNCF-certified Kubernetes with a free control plane. Add nodes when you need them, with no egress fees.

14-day money-back guarantee

Frequently asked questions

What is a Kubernetes Service?
A Kubernetes Service gives a changing set of Pods a stable network identity so clients do not need to track individual Pod IP addresses.
What are the main Kubernetes Service types?
The main Service types are ClusterIP, NodePort, LoadBalancer, and ExternalName. ClusterIP is the default internal model; the others serve specific exposure or naming requirements.
What is the difference between a Kubernetes Service and Ingress?
A Service provides stable reachability to Pods. Ingress provides HTTP/HTTPS routing rules above Services and requires an Ingress controller to implement them.
Should I use Gateway API or Ingress for a new Kubernetes application?
Gateway API is the forward-looking Kubernetes routing model and is recommended for new functionality. Ingress remains stable and supported, so existing deployments do not need migration without a concrete benefit.
When should I use a LoadBalancer Service?
Use a LoadBalancer Service when one workload needs a dedicated external endpoint, especially for TCP or UDP traffic or when shared application routing adds no value.
When should I use ClusterIP?
Use ClusterIP for workloads that only need stable reachability inside the cluster or that sit behind a Gateway or Ingress public routing layer.
Does a Kubernetes Service secure traffic between Pods?
No. A Service provides reachability. NetworkPolicy, VPC and firewall controls, TLS, authentication, and authorization handle different security layers.