Learn more about Kubernetes Session Affinity. Our Kubernetes Support team is here to help you with your questions and concerns.

All About Kubernetes Session Affinity

Kubernetes services include a configuration setting called `sessionAffinity`. By default, this setting is `None`, meaning traffic is distributed evenly across all pods. However, when `sessionAffinity` is set to `ClientIP`, Kubernetes uses the client’s IP address to ensure that subsequent requests from the same client are consistently routed to the same pod.

Kubernetes session affinity helps ensure consistent connections between a client and a specific pod within a service. This feature is especially beneficial for applications requiring stateful sessions, such as web applications and databases.

Additionally, a `sessionAffinityConfig` can be specified with a timeout, which defaults to 10800 seconds (3 hours). This timeout determines how long a client IP is bound to a specific pod.

Types of Session Affinity

• Client-IP Affinity

  It associates a client’s IP address with a specific pod. Subsequent requests from the same IP are routed to the same pod.
  It is useful for applications where the client’s IP is a reliable identifier.
• Cookie-Based Affinity

  It tracks client sessions using a session cookie. When a client first connects, a cookie is set, and subsequent requests with the same cookie are routed to the same pod. Ideal for applications where cookies are preferred for session tracking over client IPs.

Benefits of Session Affinity

• Reduces latency by keeping sessions on the same pod.
• It also ensures consistent connections, which is crucial for stateful applications.
• Furthermore, it allows developers to focus on application logic without handling session management complexities.

Limitations

• Session affinity may not work well in environments with frequently changing client IPs, such as mobile networks or cloud infrastructures with load balancers.
• While session affinity is valuable for stateful applications, it’s unnecessary for stateless applications that don’t maintain state between requests.
• Sticky sessions can limit horizontal scaling flexibility since traffic remains tied to specific pods.

Alternatives to Session Affinity

For more advanced session persistence:

• Tools like NGINX Ingress support cookie-based or header-based session persistence.
• Platforms like Istio provide sophisticated load-balancing and session management options.

Configuring Session Affinity

We can configure session affinity at the Service level using the sessionAffinity field. Here’s an example of how to configure client-IP affinity:


apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
selector:
app: my-app
ports:
- protocol: TCP
port: 80
targetPort: 8080
sessionAffinity: ClientIP


To configure cookie-based affinity, we would set the sessionAffinity field to ClientIP and specify a cookie name:


apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
selector:
app: my-app
ports:
- protocol: TCP
port: 80
targetPort: 8080
sessionAffinity: ClientIP
sessionAffinityConfig:
clientIP:
cookieName: JSESSIONID


Choosing the right type of session affinity depends on the application’s specific requirements and the desired trade-offs between performance, scalability, and statefulness.

[Need assistance with a different issue? Our team is available 24/7.]

Conclusion

Kubernetes session affinity provides a practical solution for maintaining consistent client-pod connections, enhancing application performance and user experience. By understanding its types, benefits, and limitations, and configuring it appropriately, we can optimize our Kubernetes environment for stateful workloads while balancing scalability and performance.

In brief, our Support Experts introduced us to Kubernetes Session Affinity.