NAVER Explains How to Run Socket.IO Across Multiple Kubernetes Pods Without Losing Real-Time Reliability

Scaling a real-time application from one Kubernetes Pod to several is not simply a matter of increasing the replica count. Each Socket.IO server owns active connections, while users expect messages, notifications and collaborative updates to reach them regardless of which Pod accepted their connection. A NAVER D2 Engineering Day 10th presentation, “Socket.IO 서버를 여러 Pod에서 운영하기” (“Operating Socket.IO Servers Across Multiple Pods”), examines the engineering and operational challenges behind that transition.

The Korean session description outlines NAVER's experience building its own socket server on n3r, NAVER's internal Kubernetes-based container platform. It lists connection authentication, cross-Pod event delivery, data structures and user flows, timeout management, autoscaling and redistribution, deployment and disconnection behavior, load testing and comparisons of deployment strategies. These are the topics NAVER says the presentation covers; the publicly supplied summary does not disclose the precise implementation choices, measured results or production traffic volumes.

Why multiple Socket.IO Pods change the problem

With one Socket.IO instance, a server can maintain its connected clients and room membership locally. When several instances run behind a Kubernetes Service or ingress, different clients may land on different Pods. Sending an event from one Pod does not automatically reach clients connected to another Pod if the application uses only the default in-memory adapter.

The official Socket.IO documentation for multiple nodes identifies two distinct scaling requirements: route each session correctly through load balancing and forward events between servers. Solving one does not solve the other. Session affinity cannot distribute an event across Pods; an event adapter does not automatically make a load balancer route polling requests to the correct session owner.

This distinction is fundamental for chat systems, live dashboards, collaborative editing, notifications and agent-facing applications that stream progress to users.

What NAVER's session actually covers

The NAVER D2 presentation is organized around the limitations of the previous platform and the objectives of building a new socket server; Socket.IO fundamentals and multi-Pod connection behavior; connection authentication, event delivery, data structures and user journeys; operational issues including timeouts, autoscaling, connection redistribution and deployments; and validation through load testing and deployment-strategy comparisons.

Its description says the team shares lessons learned while designing and operating a multi-Pod socket server. However, the source page could not be retrieved in full for this article, and the supplied outline does not identify which adapter, load-balancer configuration or reconnection strategy NAVER selected. The technical guidance below is based on independently accessible Socket.IO documentation and established Kubernetes operational principles, not a reconstruction of NAVER's undisclosed architecture.

Session affinity: when sticky sessions are required

Socket.IO can begin with HTTP long-polling and upgrade to WebSocket. During long-polling, a client makes multiple HTTP requests belonging to the same Socket.IO session. If a load balancer routes those requests to different Pods, the receiving Pod may not recognize the session and return an HTTP 400 error.

The official documentation recommends sticky sessions when HTTP long-polling is enabled. A load balancer or ingress can implement affinity using a suitable cookie or other supported routing mechanism. The exact implementation depends on the ingress controller, network topology and security requirements.

There is an important exception: when clients use WebSocket-only transport, sticky sessions are not required for the lifetime of a single persistent connection. The tradeoff is the loss of HTTP long-polling fallback, which may affect users on restrictive networks. The official multi-node guide documents both options. Teams should choose based on real client environments rather than treating one transport setting as universally superior.

How events travel between Pods

To broadcast events across server instances, Socket.IO uses an adapter. The default adapter stores relationships between connected sockets and rooms in memory. In a multi-Pod deployment, a compatible distributed adapter can coordinate broadcasts across instances.

One documented option is the Redis adapter. It publishes relevant packets through Redis Pub/Sub so other Socket.IO servers can forward them to their own connected clients. Socket.IO also documents other adapters, including Redis Streams and implementations backed by additional messaging systems.

A Redis adapter is an illustrative supported architecture, not a confirmed choice made by NAVER. It is also not a durable message queue: the standard Redis Pub/Sub adapter does not store messages for later delivery. If Redis becomes unavailable, broadcasts can be limited to clients connected to the originating server. Applications needing replay, stronger delivery guarantees or state recovery must evaluate the capabilities and limits of their chosen adapter and application protocol.

Authentication and authorization across instances

When connections can reach any Pod, authentication must not depend on state available only inside one process. A typical design validates a credential during the connection handshake, derives a stable authenticated identity and enforces permissions before joining rooms or receiving protected events.

Authorization also matters when events cross Pods. An application must ensure that an authenticated user may subscribe to the requested conversation, project or account. A distributed adapter transports events; it does not replace business-level permission checks.

Teams should define what happens when a token expires, a user loses access or a connection is re-established on another Pod. Credentials and personal data should be handled according to the application's security requirements, with transport encryption, least-privilege access and appropriate protection for the event backbone.

Rooms, user identity and data structures

Socket.IO rooms are useful for targeting messages to groups of connected clients. In a multi-Pod architecture, an adapter can coordinate broadcasts to room members on different servers. However, the application still needs to decide where authoritative user state, permissions and persistent business records live.

A useful distinction is between ephemeral connection state and durable application state. Socket IDs can change after reconnection; a user account or conversation identifier should remain stable. Presence information may require special treatment when clients disconnect unexpectedly or when a Pod is terminated. Avoid treating a local in-memory map as the only authoritative record for a distributed service.

These design considerations correspond to topics listed in NAVER's session outline, but the specific data structures used by NAVER are not described in the available summary.

Timeouts, heartbeats and reverse proxies

Long-lived connections can be interrupted by proxy timeouts, network changes and process restarts. The Socket.IO documentation notes that an Nginx proxy_read_timeout should exceed the sum of the Socket.IO heartbeat pingInterval and pingTimeout, otherwise a proxy may close an otherwise healthy connection.

Operators should review timeout settings at every relevant layer: the client, Socket.IO server, ingress, cloud load balancer and any additional proxy. Misaligned values can create periodic disconnects that look like application bugs. Timeout changes should be tested under real network conditions rather than made arbitrarily large.

Autoscaling does not automatically redistribute existing connections

Kubernetes Horizontal Pod Autoscaling can add replicas when configured metrics cross thresholds, but adding a Pod does not move already established WebSocket connections to it. New connections may reach the new Pod while long-lived clients remain attached to older instances.

This can create uneven load. One Pod may hold many busy connections while another is relatively idle, even when request-rate metrics appear acceptable. A useful scaling policy should consider connection counts, per-connection workload, CPU and memory, event throughput and application-specific pressure. Operators should test how traffic redistributes when clients reconnect, not assume the platform balances established sessions continuously.

When scaling down, the problem becomes more delicate: terminating a Pod disconnects its clients unless the application and infrastructure support a controlled drain and reconnection process.

Rolling deployments and graceful shutdown

Deployment strategy is one of the explicit topics in NAVER's presentation. For a multi-Pod socket service, the practical goal is to minimize avoidable disconnections and ensure clients can reconnect safely when an instance is replaced.

Teams can review Kubernetes readiness behavior, termination grace periods, pre-stop handling and the application's shutdown sequence. The application should stop accepting new connections when draining, allow in-flight work to finish where practical and communicate disconnection or reconnection state appropriately. The client should retry with bounded backoff and recover its subscriptions or application state after reconnecting.

No deployment can guarantee that a persistent socket never disconnects. The more realistic objective is graceful degradation and predictable recovery, with no duplicate business actions or lost authoritative state.

Connection recovery is not universal across adapters

Socket.IO supports connection-state recovery in certain configurations, but capabilities vary by adapter. The standard Redis Pub/Sub adapter documentation explicitly lists connection-state recovery as unsupported. Therefore, enabling a Redis adapter should not be described as automatically restoring missed events after a disconnect.

For applications that must recover missed notifications or updates, teams should consider application-level sequence numbers, persisted event histories, state synchronization or an adapter whose documented features meet the requirement. The correct choice depends on whether a missed event is merely inconvenient or could lead to an incorrect transaction.

Load testing: what should teams verify?

The NAVER session includes load testing and deployment-strategy comparison. A credible test should reproduce the actual distribution of users and events, not merely open a large number of idle sockets.

Test plans should include concurrent connections, connection establishment rate, message fan-out, room sizes, payload sizes, reconnect storms, scaling events and rolling deployments. A multi-Pod test should deliberately place connected clients on different Pods and verify that broadcasts and targeted messages reach their intended recipients.

Useful metrics include connection success rate, active connections per Pod, message delivery latency, reconnect duration, failed handshakes, adapter publish failures, CPU and memory pressure, dropped events and duplicate actions. The exact service-level objectives must be defined by the application owner; NAVER's summary does not supply benchmark thresholds.

A practical multi-Pod validation checklist

Confirm transport behavior. Identify whether clients use polling, WebSocket or both, and configure affinity where required.
Choose and test a distributed adapter. Verify cross-Pod broadcasts, targeted rooms and behavior when the adapter's backing service fails.
Make authentication portable. Ensure every Pod can validate credentials and enforce the same permissions.
Separate connection and business state. Keep durable records outside individual Pod memory.
Align timeouts. Check heartbeat intervals against ingress and load-balancer timeouts.
Test reconnects. Simulate mobile network changes, Pod termination and proxy interruptions.
Exercise scaling. Add and remove replicas while measuring connection distribution and application performance.
Compare deployments. Run realistic traffic during rolling updates and alternative rollout strategies.
Protect the event backbone. Use private networking, authentication, access controls and encryption where applicable.
Validate user outcomes. Confirm that notifications, live data and transactions remain correct—not merely that the socket connects.

Why this matters for SEO and AI Search

Socket.IO does not determine how a page ranks in Google or whether an AI assistant cites a publisher. The SEO connection is operational. Many websites rely on real-time infrastructure for live inventory, chat, notifications, customer support, collaboration or booking status. If these services fail during scaling or deployment, users may abandon a journey even when the page itself remains indexed.

For example, a travel site may present an accessible destination guide but depend on a live service to show availability or confirm a booking. An unreliable socket layer could delay updates or create uncertainty about transaction state. The site's visibility may be intact while its ability to complete the user's task deteriorates.

AI-agent workflows can introduce similar dependencies. An assistant that streams tool progress, waits for external events or coordinates multiple actions needs robust reconnect behavior and authoritative task state. A disconnected client must not cause an agent to silently lose work, invent a completion result or execute the same transaction twice.

These are architectural implications, not claims that NAVER changed its search ranking system or introduced a new AI Search feature.

How publishers and product teams should measure the impact

Rather than claiming a direct ranking lift from better socket architecture, teams should track business and reliability outcomes: successful checkouts or bookings, real-time message delivery, support-session completion, reconnection rates, user-visible errors and recovery time during releases.

Technical SEO monitoring can continue separately with crawl availability, rendered-content checks and page-performance data. If a real-time service powers essential content, verify that a temporary socket failure does not leave primary information permanently inaccessible to users or crawlers.

Frequently asked questions

What did NAVER discuss at Engineering Day 10th?

A session about designing, validating and operating Socket.IO servers across multiple Kubernetes Pods on NAVER's internal n3r platform, covering event delivery, authentication, timeouts, scaling, deployment and load testing.

What is n3r?

In this presentation, n3r is NAVER's internal Kubernetes-based container platform, not a separate public Socket.IO product.

Do multiple Socket.IO Pods need Redis?

They need a suitable mechanism for forwarding events across server instances. Redis is one officially documented adapter option, not the only possible choice.

Are sticky sessions always required?

No. They are needed when HTTP long-polling is enabled across multiple servers. A WebSocket-only transport can avoid that requirement, at the cost of removing the polling fallback.

Does adding Kubernetes replicas move existing WebSocket connections?

No. Existing persistent connections remain associated with their current server until disconnected or re-established.

Does the Redis adapter preserve missed messages?

The standard Redis Pub/Sub adapter does not provide durable message storage or built-in connection-state recovery. Applications needing replay must design for it explicitly.

What should a load test measure?

Connection rates, concurrent sessions, cross-Pod delivery, message latency, reconnect behavior, scaling distribution, deployment disruption and task-level correctness.

Does a multi-Pod Socket.IO setup improve SEO rankings?

Not directly. Reliability may support better user experiences and dependable service completion, but it is not a demonstrated search-ranking or AI-citation factor.

The bottom line

NAVER's Engineering Day session draws attention to the less visible challenges of scaling real-time services: session routing, event propagation, authentication, connection lifetime, autoscaling, deployment and recovery. Official Socket.IO guidance confirms that multi-server operation requires deliberate choices at both the load-balancing and messaging layers.

For teams building search-driven websites and AI-enabled services, the central lesson is to evaluate successful user actions under real operating conditions, not just the number of running Pods. A scalable architecture is only useful when events reach the right people and applications recover predictably from change and failure.