When it comes to gameserver performance what tends to be the biggest issue is predictable performance. So, kubernetes is not inherently antithetical to running game servers as long as you don’t share the cpu core(s) with anything.
In fact there is a project that (while I was not a part of) was spearheaded by ubisoft in collaboration with Google for running game servers on Kubernetes (called Agones)[1].
Ubisoft also used “Thunderhead” (which this project seems to be a variant of) on Azure with rainbow 6 siege. So it’s definitely not considered a show-stopping problem.
When it comes to containers/VMs the biggest hit in terms of performance is in this order: disk/network/memory access/CPU ;; when talking about game servers the most important things go in the reverse of that order, which means that the biggest performance losses are not as important. Network latency might seem like a big deal but you’re limited to frame times in the best case and geographical differentiations will eat much more than the combined weight of frames and Kubernetes networking.
Agones itself bypasses a lot of the Kubernetes networking latency additions, though, not all.
It’s quite old now but interesting for anyone whose experience is purely running on their own hardware.
Mostly reliant on (hardware offloaded) network latency, memory, and storage. Consistency being the thing of most importance. A spike is felt - interpolation can only go so far
CPU virtualization extensions make the latency cost of VMs hardly noticeable, containers are technically better but it's a split hair.
On an unloaded host and a single VM you can achieve essentially identical performance as bare metal - the CPU extensions, pinning cores, and huge pages are key
Some performance metrics even improve! Disk operations tend to do better from an added layer of memory involvement
Edit: there are options for multi-tenant fairness whichever way you go -- Bare metal, VMs, or containers
Performance isn't much of a worry, more so the 'handles'
There are exceptions. For years you could only run Satisfactory servers by the server acting like a client - rendering and all
In this case they seem to be NAT'ing packets from a host port on the correct Kubernetes node (the one running the container) to a port in the container, which can be done fast enough with iptables (or similar mechanism used by Kubernetes).
iptables is a good example -- it can scale rather poorly! Packets are run across the chains at length until a matching rule is found.
For most configurations this isn't a problem - the rules are filtered against quickly.
If density reaches the point to where you have thousands of forwards, it'll slow down a lot!
You'll want to look into optimizations (eg: ipsets), offloading to hardware, or simply going to host networking
Alas, it still does; at least for the Java client.
Or perhaps more realistic you could provision a tier of very low latency VMs.