What are the Kubernetes Service types?

A Kubernetes Service gives a changing set of Pods one stable address, and its type decides who can reach that address. ClusterIP, the default, is reachable only inside the cluster. NodePort also opens a port between 30000 and 32767 on every node, LoadBalancer also puts an external load balancer in front of those nodes, and ExternalName is only a DNS alias for a hostname outside the cluster. A headless Service is a ClusterIP variant with no virtual IP, which returns the Pod IPs directly.

Why Services exist

Pods are replaced on every rollout, rescheduling and scale event, and each new Pod gets a new IP address. A Service selects Pods by label, tracks the ready ones in EndpointSlice objects and gives clients a virtual IP and a DNS name that stay the same. kube-proxy, or a CNI plugin that replaces it, programs each node to forward traffic for that virtual IP to one of the ready Pods. The Kubernetes DNS service publishes the name, such as api.shop.svc.cluster.local.

The types compared

TypeReachable fromWhat Kubernetes sets upTypical use
ClusterIPInside the clusterA virtual IP and a DNS nameInternal APIs, databases, the backend of an Ingress or Gateway
NodePortAny node IP, on a port from 30000 to 32767A cluster IP plus the same port on every nodeYour own external load balancer, quick tests
LoadBalancerThe load balancer’s addressA cluster IP, a node port and an external load balancerExposing TCP or UDP services to the internet or a private network
ExternalNameInside the cluster, by DNSA CNAME record only, no proxyingA stable in-cluster name for an external database or API
Headless (clusterIP: None)Inside the cluster, by DNSDNS records that return each Pod IPStatefulSets, clients that pick their own backend

The Service documentation describes the first three as nested: a NodePort Service also gets a cluster IP, and a LoadBalancer Service also gets a cluster IP and a node port.

ClusterIP

Kubernetes assigns the Service an IP address from the cluster’s Service range, and clients inside the cluster connect to that IP or the DNS name. Nothing outside the cluster can reach it. Most Services are of this type, including those that an Ingress controller or Gateway routes HTTP traffic to.

NodePort

The control plane allocates a port from the range set by the API server flag --service-node-port-range, which defaults to 30000 to 32767, and every node forwards that port to the Service. It is useful when you run your own load balancer in front of the nodes, but clients must know the node addresses.

LoadBalancer

Kubernetes creates the node port, and then a load balancer controller provisions an external load balancer that forwards to it and writes the address into the Service status. Implementations can skip the node port and send traffic straight to Pods if you set allocateLoadBalancerNodePorts: false, provided the implementation supports it.

ExternalName

The Service has no selector and no IP. Cluster DNS answers lookups for its name with a CNAME to the hostname in externalName, for example orders-db.prod.svc.cluster.local to db.example.com. The documentation warns that this breaks protocols that depend on the hostname: HTTP requests carry a Host header the origin does not recognize, and TLS servers cannot present a certificate for the name the client used.

Headless Services

Setting clusterIP: None skips the virtual IP and the proxying. DNS returns the IP of every ready Pod instead, and with a StatefulSet each Pod also gets its own stable name, such as postgres-0.postgres.db.svc.cluster.local. Databases and other clustered systems that need to address individual members use headless Services.

Who provisions a LoadBalancer

Kubernetes ships no load balancer. In a cloud, the cloud-controller-manager watches LoadBalancer Services and calls the provider’s API to create a load balancer that targets the nodes. The optional loadBalancerClass field, stable since Kubernetes 1.24, hands the Service to a different implementation instead of the provider default.

If no controller handles the Service, nothing fails loudly: kubectl get svc shows EXTERNAL-IP as <pending> indefinitely. This is the normal state on bare metal, on-premises and on many local clusters. MetalLB, Cilium and kube-vip fill the gap there, as explained in how LoadBalancer Services work on bare-metal Kubernetes.

To request a specific address, use your implementation’s annotation. The spec.loadBalancerIP field has been deprecated since Kubernetes 1.24 because its meaning varies between providers.

External traffic policy and client IPs

The externalTrafficPolicy field controls what happens to traffic that arrives at a node from outside, through a node port or a load balancer. The source IP tutorial shows the effect of each setting.

Cluster (default)Local
Which nodes accept trafficEvery nodeOnly nodes that run a ready Pod of the Service
Extra hopPossible, the node forwards to a Pod on another nodeNone
Client source IP seen by the PodThe node’s IP, because the packet is source-NATedThe real client IP
Load spreadEven across PodsEven across nodes, so uneven if Pods are unevenly spread

With Local, Kubernetes allocates a healthCheckNodePort. The load balancer’s health checks fail on nodes without a local Pod, so it stops sending traffic to them. Choose Local when the application needs the client IP for logging, rate limiting or allow lists, or when the extra hop crosses zones or providers and costs money, and spread the Pods evenly across nodes.

The matching internalTrafficPolicy field applies the same choice to traffic from inside the cluster. The trafficDistribution field expresses a softer preference, such as PreferSameZone, without dropping traffic when no local Pod exists.

One load balancer per Service adds up

Each LoadBalancer Service usually becomes its own cloud load balancer with its own hourly charge. As of November 2026, an AWS Network Load Balancer in US East (N. Virginia) costs $0.0225 per hour, about $16 per month, plus $0.006 per capacity unit hour, according to the Elastic Load Balancing pricing page. Ten public services mean ten load balancers, ten addresses and ten sets of firewall rules.

For HTTP and HTTPS, the usual pattern is one LoadBalancer Service for an Ingress controller or a Gateway, which then routes requests by hostname and path to ClusterIP Services. The article on Ingress and Gateway API covers that layer. Protocols that are not HTTP, such as databases, MQTT or game servers, usually keep a LoadBalancer Service each. Traffic through load balancers and between zones also shows up on the bill, as described in what network costs Kubernetes adds.

LoadBalancer Services on Cloudfleet

By default, for a LoadBalancer Service, Cloudfleet Kubernetes Engine (CFKE) provisions a load balancer in every cloud provider and region where the cluster has nodes, and gives the Service a stable DNS name that survives those load balancers changing. Setting externalTrafficPolicy: Local limits load balancers to the locations that run the Service’s Pods. The load balancing guide lists the supported providers and annotations.

On this page