June 26, 2025 13 min to read

Understanding Kubernetes Endpoints and EndpointSlices

A comprehensive guide to service discovery mechanisms in Kubernetes

Image Reference Link

Understanding Kubernetes Endpoints and EndpointSlices

In Kubernetes, services route traffic to pods, but how does a service know which pods to target?

This is where Endpoints and EndpointSlices come in - they store the mapping between services and the actual pods that receive the traffic.
Understanding these resources is crucial for managing large-scale Kubernetes environments effectively.

What are Endpoints?

Endpoint Basics

An Endpoint resource in Kubernetes is essentially an address book that contains the IP addresses and ports of all pods matching a service’s selector. When you create a service, Kubernetes automatically:

• Creates a corresponding Endpoint object with the same name as the service
• Tracks pods matching the service’s selector
• Updates the Endpoint object whenever pods are created, deleted, or modified
• Uses this information to direct traffic to the right destinations

Endpoints Example

kind: Endpoints
apiVersion: v1
metadata:
  name: my-service
subsets:
  - addresses:
      - ip: 10.233.65.100
      - ip: 10.233.65.101
      - ip: 10.233.65.102
    ports:
      - port: 8080

What are EndpointSlices?

EndpointSlices are an evolution of the Endpoints concept, designed to address scalability issues in large Kubernetes clusters. They divide the network endpoint information into multiple smaller resources, providing better performance and scalability.

EndpointSlice Example

kind: EndpointSlice
apiVersion: discovery.k8s.io/v1
metadata:
  name: my-service-abc
  labels:
    kubernetes.io/service-name: my-service
addressType: IPv4
ports:
  - name: http
    protocol: TCP
    port: 8080
endpoints:
  - addresses:
      - "10.233.65.100"
      - "10.233.65.101"
    conditions:
      ready: true
    nodeName: node-1

---
kind: EndpointSlice
apiVersion: discovery.k8s.io/v1
metadata:
  name: my-service-xyz
  labels:
    kubernetes.io/service-name: my-service
addressType: IPv4
ports:
  - name: http
    protocol: TCP
    port: 8080
endpoints:
  - addresses:
      - "10.233.65.102"
    conditions:
      ready: true
    nodeName: node-2

Key Features of EndpointSlices

EndpointSlices improve upon Endpoints in several ways:

• Sliced Storage: Divides endpoints into multiple smaller resources
• Enhanced Fields: Includes node name, topology, and conditions
• Scalability: Each slice typically contains up to 100 endpoints
• Multiple Address Types: Supports IPv4, IPv6, and FQDN
• Better Update Performance: Only affected slices need to be updated

Evolution: From Endpoints to EndpointSlices

Why EndpointSlices Replaced Endpoints

The transition from Endpoints to EndpointSlices was driven by real-world scalability problems encountered in large Kubernetes clusters. Understanding these challenges helps appreciate why this evolution was necessary.

The Problems with Endpoints

How EndpointSlices Solve These Problems

Detailed Comparison

Let’s compare Endpoints and EndpointSlices across multiple dimensions to better understand their differences and capabilities.

How kube-proxy Uses Endpoints/EndpointSlices

The kube-proxy component is responsible for implementing the Kubernetes Service concept at the network level. Understanding how it interacts with Endpoints and EndpointSlices helps grasp the full picture of service discovery in Kubernetes.

kube-proxy Configuration

# kube-proxy ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: kube-proxy
  namespace: kube-system
data:
  config.conf: |-
    apiVersion: kubeproxy.config.k8s.io/v1alpha1
    kind: KubeProxyConfiguration
    mode: "iptables"
    featureGates:
      EndpointSliceProxying: true # Default is true in Kubernetes 1.22+

Performance Comparison at Scale

The true benefits of EndpointSlices become apparent as clusters scale. Let’s examine how performance differs between Endpoints and EndpointSlices under various conditions.

Practical Examples

Let’s walk through some practical examples of how Endpoints and EndpointSlices are created and managed in a Kubernetes cluster.

Example 1: Creating a Service and Observing Endpoints

# Create a deployment with 3 replicas
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80
---
# Create a service for the deployment
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80

After applying this YAML, Kubernetes automatically creates:

1. An Endpoint object named nginx-service
2. EndpointSlice object(s) with the label kubernetes.io/service-name: nginx-service

Example 2: Scaling the Deployment

When you scale the deployment up or down, you can observe how differently Endpoints and EndpointSlices are updated:

# Scale to 10 replicas
kubectl scale deployment nginx-deployment --replicas=10

# Observe changes
kubectl get endpoints nginx-service -o yaml
kubectl get endpointslices -l kubernetes.io/service-name=nginx-service

Managing and Troubleshooting

When working with Kubernetes services, understanding how to inspect and troubleshoot Endpoints and EndpointSlices is essential.

Common Commands

Troubleshooting Service Connectivity Issues

# Check if endpoints exist for a service
kubectl get endpoints my-service

# If endpoints exist but service still doesn't work, check pod readiness
kubectl get pods -l app=my-app -o wide

# Examine EndpointSlices for more details
kubectl get endpointslices -l kubernetes.io/service-name=my-service -o yaml

# Check kube-proxy logs for issues
kubectl logs -n kube-system -l k8s-app=kube-proxy

Best Practices

Based on the evolution from Endpoints to EndpointSlices, here are some best practices for managing service discovery in Kubernetes.

Future Developments

Service discovery in Kubernetes continues to evolve. Several enhancements to EndpointSlices are under development or consideration.

Summary

References

• Kubernetes Documentation: EndpointSlices
• Kubernetes Blog: Introducing EndpointSlices
• Kubernetes EndpointSlice Controller
• KEP-0752: EndpointSlices
• LinkedIn: Kubernetes Concept - Endpoints vs EndpointSlices