Kubernetes Networking in Plain Language: Pods, Services, Ingress
At some point in the meeting, the words start arriving faster than you can look them up. The pods talk to the service. The service is fronted by the ingress. The ingress needs a controller. And could you take a look because "it might be a network thing"? Everyone nods. You nod too, while privately wondering when your network grew a vocabulary you never approved. If your dev team has deployed a Kubernetes cluster, this experience is not a sign you have fallen behind. It is a sign nobody handed you the translation card.
Here is the honest secret. Kubernetes networking, at the level a generalist admin needs it, is three ideas stacked on top of each other. All three are ideas you already know from ordinary networking — just wearing new names. There is a deep end, and this guide will point at it so you know it exists. But you are not required to swim in it. People earn certifications on the deep end. You have a network to run.
By the end of this guide you will have the three-layer mental model — pods, services, ingress. You will have a working grasp of cluster DNS (which quietly underlies most "cluster networking" tickets). You will have a plain answer to how traffic actually gets into a cluster. You will also have an honest one-paragraph version of the internals you can safely skip. And you will have a vocabulary table you can keep open during the next meeting. Nodding will be optional.
In this guide
- The three-layer mental model
- Layer 1 — pods: disposable workers
- Layer 2 — services: the receptionist
- Layer 3 — ingress: the building's front door
- Cluster DNS: where most tickets actually live
- How traffic actually gets in
- What you can safely not memorize
- The vocabulary table
The three-layer mental model
Picture the cluster as an office building. The pods are the workers inside: they do all the actual work. They sit at whatever desk was free that day. And they are hired and let go constantly. You would never give a customer a specific worker's desk extension. The services are the reception desk: a stable, published phone number per department. Reception keeps a live directory of which workers are in today and connects each caller to one of them. Callers neither know nor care which. The ingress is the building's street entrance: one front door for outside visitors. Its signage routes each of them to the right reception desk based on who they ask for.
That is the entire model: disposable workers, stable reception desks, one signposted front door. Every Kubernetes networking conversation you will be pulled into is about one of these three layers. And the first diagnostic question is always the same — which layer are we actually talking about? Traffic between workers is one kind of problem, reception's directory being stale is another, and the front door being locked is a third. Keep the building in mind and the jargon becomes labels instead of fog.
Layer 1 — pods: disposable workers
A pod is the smallest unit Kubernetes deploys: one or more containers that are glued together and share a single network identity. From the network's point of view, a pod behaves like one tiny host. It gets exactly one IP address. The containers inside it share that address the way processes on one server share theirs. When people say "the app runs in twelve pods," translate it as "twelve small, identical, disposable hosts." Each pod's address comes from a large flat range the cluster manages itself. That is why a cluster can casually introduce hundreds of addresses your IPAM has never heard of.
Two facts about pod addresses matter to you. First, inside the cluster they are real and routable. By default any pod can reach any pod directly, across all the cluster's machines, with no NAT in between. Kubernetes flattened the internal network on purpose, and yes, that default is as permissive as it sounds. That is a point worth remembering when security comes up. Second, the addresses are disposable by design. Pods are replaced on every deployment, every scale-up, every crash, every node failure; the replacement gets a fresh address. Nothing sensible is ever configured to point at a pod IP, for the same reason nothing sensible mails a letter to "the third desk from the window."
$ kubectl get pods -o wide NAME READY STATUS IP NODE webshop-7d9c44b6-fk2xp 1/1 Running 10.244.1.17 node-2 webshop-7d9c44b6-pv8sl 1/1 Running 10.244.3.42 node-1 webshop-7d9c44b6-zc4mn 1/1 Running 10.244.2.9 node-3
That is the view devs see all day: three identical workers, three throwaway addresses, scattered across three machines. Tomorrow the names and IPs will differ and nobody will blink. The NODE column, meanwhile, contains the one word in Kubernetes that means exactly what you hope. A node is a server that runs pods. A physical box or a VM, with a NIC, an OS, and an IP address on your network, doing everything servers normally do. You will meet nodes again in the monitoring guide, because they are the part of the cluster that lives squarely in your comfort zone.
Layer 2 — services: the receptionist
If pods are disposable, something stable has to sit in front of them, and that something is the service. A service is a stable virtual address plus a DNS name that represents a group of pods. Callers connect to the service; the cluster forwards each connection to one of the pods currently backing it, spreading the load as it goes. When pods die and are replaced, the service's directory updates automatically within seconds. The receptionist analogy is nearly exact: a published number that never changes, answered by whoever is at a desk today.
How does the receptionist know who is in? Through labels and selectors. Pods carry labels — simple name tags like app=webshop — and each service has a selector saying "I front every pod labeled like this." The resulting live directory is called the service's endpoints: the actual list of pod addresses behind the desk right now. File that word away. When service traffic mysteriously goes nowhere, "check the endpoints" is the single most useful sentence you can say. The troubleshooting guide in this series leans on it hard.
$ kubectl get service webshop NAME TYPE CLUSTER-IP PORT(S) webshop ClusterIP 10.96.14.201 80/TCP $ kubectl get endpoints webshop NAME ENDPOINTS webshop 10.244.1.17:8080,10.244.2.9:8080,10.244.3.42:8080
One honest wrinkle so the address in that output does not mislead you: a service IP is virtual. No NIC anywhere carries 10.96.14.201, nothing answers ping there, and you cannot find it with a switch. Each cluster machine quietly rewrites traffic aimed at the service address so it lands on a real pod instead. The receptionist transfers your call rather than taking it herself. Treat service IPs as a useful bookkeeping fiction, reachable only from inside the cluster, and their behavior stops being spooky. If you have run load balancers, the shape is an old friend: a virtual IP in front of a backend pool whose membership updates itself.
Layer 3 — ingress: the building's front door
Pods and services are both cluster-internal so far. The ingress layer is how the outside world gets in. An ingress is a set of routing rules at the cluster's edge, almost always for web-style traffic. Requests for shop.example.com go to the webshop service. Requests for api.example.com go to the API service. Anything asking for /reports goes to the reporting service. One front door, many tenants, routed by hostname and path. If you have ever configured a reverse proxy, you have already written an ingress in a different file format.
One vocabulary trap hides here. The ingress rules are just configuration — a rulebook. The software that actually stands at the door enforcing them is the ingress controller. It is a reverse proxy running inside the cluster, listening on a real, reachable address. The distinction matters on bad days, because "the ingress is broken" can mean the rulebook is wrong or the doorman has collapsed. Those are different investigations. This front door is also where TLS certificates usually live. More relevant to you than anything else in this section: it is the address your monitoring should be probing from outside. That is because it is what users actually experience.
Notice what quietly became shared ground: the hostnames. The names users type live in ordinary public or internal DNS — your territory — and they must point at the ingress entry address. If that record is wrong or stale, every layer inside the cluster can be perfectly healthy while users see nothing at all. When a cluster gets a new app, "who updates the DNS record, and to what address?" is a question worth asking out loud. That is because both teams routinely assume the other one did it.
Cluster DNS: where most tickets actually live
Now the quiet layer under all three. Every service automatically gets a DNS name, published by a DNS server that runs inside the cluster itself. The full names follow a pattern worth recognizing on sight. webshop.production.svc.cluster.local means the service webshop in the namespace production. A namespace is nothing scarier than a folder used to group things, like departments in the building. Applications inside the cluster find each other almost exclusively through these names. Short forms work too: a pod in the same namespace can just ask for webshop.
Why does this deserve its own section? Because in practice, a large share of "the cluster networking is broken" tickets are DNS tickets wearing a costume. When applications cannot find each other by name, everything looks down while every wire, switch, and NIC is innocent. It is the same illusion you have seen on the regular network, now indoors. The classic joke gets a promotion here, and why it's always DNS explains the underlying reasons, every one of which applies inside a cluster too. The practical takeaways for a generalist start here: the cluster runs its own DNS. That DNS lives in pods like everything else (yes, the phone book is printed by workers inside the building). And "do service names resolve from inside?" is the first question of any internal connectivity investigation. The quick test costs one command from inside any pod: look up a service name. If the name fails while a pod IP works, you have found the layer. The troubleshooting playbook walks through exactly that sequence.
Tip: the word "service" is brutally overloaded. Devs may mean the Kubernetes service object, the application itself, or a Windows service on some unrelated box. When a ticket says "the service is down," ask which one before you route a single packet's worth of effort. Fifteen seconds of clarification regularly saves an hour of investigating the wrong layer.
How traffic actually gets in
"How does traffic enter the cluster?" sounds like it should have one answer; it has three, and clusters commonly use two of them at once. All three are generic mechanisms rather than products, and each maps to something you already know.
A NodePort opens the same high-numbered port on every node in the cluster. Traffic arriving at any node on that port is forwarded to the service, wherever its pods happen to live. It is a port-forward rule stamped onto every server at once — crude, dependable, and how you sometimes reach things when nothing fancier exists. A load balancer service asks the environment for a dedicated external balancer whose address fronts one service. This is effortless in a cloud. On premises it works only if something in the environment has been set up to hand out such addresses. That is often a question worth asking your dev team directly. An ingress controller is the usual endgame for web traffic. The controller itself is exposed through one of the first two mechanisms, and everything else hides behind it, routed by hostname. One address to publish in external DNS, one certificate home, one front door for your firewall rules and your synthetic checks.
| Entry method | What it is | Familiar equivalent | Where you'll see it |
|---|---|---|---|
| NodePort | Same high port opened on every node, forwarding to one service | A port-forward rule on every server at once | Labs, quick internal tools, building blocks |
| Load balancer service | A dedicated external balancer address per service | A VIP on a hardware load balancer | Clouds mostly; on-prem only if provided |
| Ingress controller | One exposed reverse proxy routing by hostname and path | Reverse proxy in front of many web apps | Nearly every cluster serving web traffic |
For your firewall and monitoring, the punchline is comforting. However exotic the inside is, the outside of a cluster presents as a short list of reachable addresses and ports. Get that list from the dev team, write it down, and treat every address on it as a front door worth checking.
What you can safely not memorize
Two topics dominate the deep end, and a generalist needs exactly one honest paragraph of each. The first is the CNI — Container Network Interface — which sounds like hardware but is a plug-in standard. It is the pluggable component that physically wires pods to the network and moves pod traffic between nodes. Different CNI plugins do it differently. Some route pod subnets like a normal routed network. Some wrap pod traffic in tunnels between nodes (an approach with real monitoring consequences, covered in the east-west visibility guide). What you need is not how your cluster's plugin works but merely which one it is and whether it tunnels. Ask one question of the dev team, put one line in your documentation, and you are done.
The second is how services are implemented. That stable-virtual-address magic is performed by an agent on every node (commonly kube-proxy) that programs packet-rewriting rules. Historically, it has done this via iptables, translating service addresses into current pod addresses. On a busy cluster this amounts to thousands of machine-written rules, regenerated continuously. You never read them or edit them. You diagnose service problems at the level of services and endpoints, not rules. This is for the same reason you troubleshoot a spreadsheet in the cells, not in the file's bytes. Knowing the machinery exists is worth one sentence of credibility in a meeting; memorizing it is worth nothing at all.
Skipping these is not falling short of some standard. The dev team skips the internals of your routing protocols and remains gainfully employed. The arrangement is symmetrical. Both sides work better when each trusts the other's abstraction until there is a specific reason not to.
The vocabulary table
Keep this open during your next cross-team meeting. The middle column is the plain meaning; the right column is the concept from your world that it rhymes with. The rhymes are not perfect — no analogy survives contact with an architect — but every one of them points your intuition in the right direction.
| Term | Plain meaning | Closest familiar thing |
|---|---|---|
| Node | A server that runs pods | A server. Genuinely just a server |
| Pod | Smallest deployed unit; one IP; disposable | A tiny short-lived VM |
| Service | Stable virtual address and name for a set of pods | A VIP on a load balancer |
| Endpoints | The live list of pod addresses behind a service | The load balancer's backend pool |
| Ingress | Hostname and path routing rules at the edge | Reverse proxy configuration |
| Ingress controller | The proxy software enforcing those rules | The reverse proxy itself |
| Namespace | A folder grouping cluster objects; part of DNS names | Departments, or OUs in a directory |
| Cluster DNS | Internal DNS answering for service names | Your internal DNS zone, indoors |
| NodePort | Same port opened on every node for one service | A port-forward on every host at once |
| CNI | The plug-in that wires pods and moves inter-node pod traffic | The cabling and switching layer, as software |
Where to go next
Three layers, one building: disposable pods behind stable services behind a signposted front door. Cluster DNS sits underneath, and a short list of real entry points faces your network. That model is enough to follow nearly any conversation your dev team will have in front of you. It is also enough to know which layer a problem lives in, which is most of diagnosis. The practical sequels are ready when you are. Monitoring a Kubernetes Cluster Without Becoming a K8s Expert turns the model into a watchlist. And When the Cluster Can't Talk turns it into a test sequence for the day something breaks. The rest of the pillar lives at Container & Kubernetes Networking for Generalists.
Put this into practice with SysPeep Monitor
You do not need cluster credentials to keep an eye on a cluster. SysPeep Monitor watches the parts that face your network. It watches the nodes (they are servers — it monitors CPU, memory, disk, and NICs over SNMP, WMI, or SSH). It also watches the front-door addresses users depend on, with alerts the moment one stops answering. Auto-discovery finds the hosts. The free trial runs on any Windows machine.
Download Free TrialLearn About SysPeep