El OOMKill que no venía de las peticiones
En el proyecto M.U.M.N.K8s tenía una API en Rust detrás del Gateway de GKE, con 3 réplicas y un límite de 256 MiB por pod. En la ronda de alta carga, a unas 1 250 peticiones por segundo, Locust empezó a reportar entre 31 % y 55 % de respuestas 503. Los tres pods de rust-api estaban en OOMKilled, uno tras otro, y mientras reiniciaban el balanceador no tenía a quién mandarle tráfico.
La primera hipótesis
Lo obvio era pensar en peticiones en vuelo: si el servicio de Go se vuelve lento, rust-api acumula peticiones esperando respuesta y cada una ocupa memoria. Agregué un semáforo que limita las peticiones en vuelo y subí el límite a 384 MiB. Mejoró, pero en otra corrida un pod volvió a morir. El semáforo no explicaba toda la memoria.
Medir en vez de suponer
Entré a un pod y conté las conexiones TCP establecidas, que son las líneas con estado 01 en /proc/net/tcp:
kubectl -n mumnk8s exec <pod-rust-api> -- sh -c \
'awk "NR>1 && \$4==\"01\"" /proc/net/tcp /proc/net/tcp6 | wc -l; grep VmRSS /proc/1/status'
# 8774
# VmRSS: 330840 kB
Casi 8 800 conexiones abiertas en un solo pod. El Application Load Balancer de Google abre conexiones desde muchos de sus nodos y las mantiene en keep-alive durante 10 minutos. Cada una ocupa unos 38 KB en rust-api (la tarea de tokio y los buffers de hyper). La memoria dependía de cuántas conexiones abría el balanceador, no de cuántas peticiones había en vuelo.
La corrección
Cerrar las conexiones antes desde el backend no era buena idea: Google recomienda que el keep-alive del backend sea mayor que el del balanceador, para no responder 502 cuando el backend cierra una conexión que el balanceador iba a reutilizar. Así que dimensioné el límite con lo medido: 512 MiB, contra un pico de 381 MiB. La validación dio 0 fallos a 1 288 peticiones por segundo, un pico de 305 MiB y 0 reinicios. El semáforo se quedó como protección para cuando Go se vuelva lento.
Lo que me llevo
La primera explicación razonable no siempre es la causa. Cuando un número no cuadra, conviene contar el recurso directamente en el sistema, en este caso un wc -l sobre /proc/net/tcp, antes de cambiar más configuración.
The OOMKill that didn't come from requests
In the M.U.M.N.K8s project I had a Rust API behind the GKE Gateway, with 3 replicas and a 256 MiB limit per pod. In the high-load round, at about 1,250 requests per second, Locust started reporting between 31% and 55% 503 responses. All three rust-api pods were OOMKilled, one after another, and while they restarted the load balancer had nowhere to send traffic.
The first hypothesis
The obvious suspect was in-flight requests: if the Go service slows down, rust-api piles up requests waiting for answers and each one takes memory. I added a semaphore to cap in-flight requests and raised the limit to 384 MiB. It got better, but on another run a pod died again. The semaphore didn't explain all the memory.
Measure instead of guessing
I went into a pod and counted established TCP connections, which are the lines with state 01 in /proc/net/tcp:
kubectl -n mumnk8s exec <pod-rust-api> -- sh -c \
'awk "NR>1 && \$4==\"01\"" /proc/net/tcp /proc/net/tcp6 | wc -l; grep VmRSS /proc/1/status'
# 8774
# VmRSS: 330840 kB
Almost 8,800 open connections in a single pod. Google's Application Load Balancer opens connections from many of its nodes and keeps them alive for 10 minutes. Each one takes about 38 KB in rust-api (the tokio task and hyper's buffers). Memory depended on how many connections the load balancer opened, not on how many requests were in flight.
The fix
Closing connections early from the backend wasn't a good idea: Google recommends a backend keep-alive longer than the load balancer's, to avoid 502s when the backend closes a connection the balancer was about to reuse. So I sized the limit from the measurement: 512 MiB, against a 381 MiB peak. The validation run gave zero failures at 1,288 requests per second, a 305 MiB peak and zero restarts. The semaphore stayed as protection for when Go gets slow.
What I take from it
The first reasonable explanation isn't always the cause. When a number doesn't add up, it pays to count the resource directly on the system, here a wc -l over /proc/net/tcp, before changing more configuration.