Kubernetes Networking and Storage Architecture

Serdar Tekin
Serdar Tekin
Co-Founder & CTO
Updated Nov 17, 202617 min read
Written for: Platform engineers and developers designing Kubernetes traffic, private networking, persistent storage, and recovery.
KubernetesNetworkingStorageGateway APINetworkPolicyPersistent VolumesVPC
Last reviewed:
Guide
Kubernetes Networking and Storage Architecture
rafftechnologies.com/learn
On this page

Key Takeaways

Separate Services, traffic entry, NetworkPolicy, and VPC controls. Treat PVC/PV persistence separately from backup. Evaluate Gateway API for new routing designs.

Free control plane

Get managed Kubernetes with persistent volumes, worker nodes from $9.99 a month.

CNCF-certified Kubernetes with a free control plane. Add nodes when you need them, with no egress fees.

Kubernetes networking and storage architecture answers two separate production questions: how traffic reaches a workload and what data survives when Pods are replaced.

For a small team, the cleanest design is to keep these layers explicit. Raff Technologies uses the same separation in its managed Kubernetes platform: worker nodes live on private networking, public traffic enters through a managed endpoint and Kubernetes traffic-routing resources, while stateful workloads use storage independently from an individual Pod's lifecycle.

The architecture can be summarized as:

Text
Traffic path Client → Gateway / Ingress / LoadBalancer → Service → Pod State path Pod → PVC → PV → StorageClass / storage backend → backup / recovery

A Service gives changing Pods a stable network identity. Gateway API or Ingress controls external application traffic. NetworkPolicy restricts allowed Pod traffic when the cluster network implementation enforces it. PersistentVolumes and StorageClasses provide durable mounted storage, while backups solve a different problem: recovery after deletion, corruption, or larger failure.

This guide owns the architecture boundary between those systems. For implementation details, continue to the dedicated guides on Kubernetes Services, Ingress, and Load Balancers, Kubernetes DNS and Service Discovery Troubleshooting, Kubernetes Network Policies, and Kubernetes Persistent Storage.

Kubernetes networking has five distinct layers

Treating "Kubernetes networking" as one feature makes production troubleshooting harder. A more useful model separates five responsibilities.

LayerPrimary responsibilityTypical Kubernetes/cloud object
Pod networkPod-to-Pod reachabilityCNI / cluster network
Service discoveryStable identity for changing PodsService + EndpointSlice + DNS
External traffic entryBring traffic into ServicesGateway API, Ingress, Service type LoadBalancer
Workload segmentationRestrict allowed trafficNetworkPolicy
Infrastructure boundaryKeep nodes and adjacent cloud resources privateVPC, firewall

The layers cooperate, but they are not substitutes for one another.

A private VPC does not automatically prevent every Pod from talking to every other Pod. A NetworkPolicy does not replace an infrastructure firewall. An Ingress does not replace Service discovery. A Service does not automatically make the application public.

The architecture becomes easier to review when every application dependency can be mapped to one of these layers.

Pod networking is the cluster reachability layer

Each Kubernetes Pod receives its own network identity inside the cluster. Containers in the same Pod share a network namespace and can communicate over localhost; communication between Pods is provided by the cluster network implementation.

A simplified internal path looks like this:

Text
Pod A ↓ cluster network ↓ Pod B

The application should not depend on individual Pod IP addresses being permanent. Pods are replaceable. They can be recreated after a deployment, node failure, rescheduling event, or scaling action.

That is why production applications normally depend on Services, not on Pod addresses.

For teams operating several nodes, this distinction also separates the cloud network from the Kubernetes network. The VPC carries node and infrastructure connectivity; the Kubernetes network provides workload-level reachability on top of that infrastructure.

Services provide stable workload identity

A Kubernetes Service gives clients a stable way to reach a changing group of Pods.

Conceptually:

Text
Client workload ↓ Service ↓ EndpointSlices ↙ ↘ Pod A Pod B

The Service remains stable while backend Pods can change.

Use a Service when:

  • an API must be reachable by several other workloads;
  • a deployment can have multiple replicas;
  • Pods may be rescheduled between nodes;
  • DNS-based discovery is preferable to hard-coded addresses.

A Service is therefore part of service discovery and traffic distribution, not persistent state.

For the detailed differences between ClusterIP, NodePort, LoadBalancer, and application-routing layers, use Kubernetes Services Explained: Ingress and Load Balancers.

Gateway API is the forward-looking application traffic model

For HTTP, HTTPS, gRPC, and other routed application traffic, Kubernetes now has two important API families: Ingress and Gateway API.

Ingress remains stable and widely deployed, but the Kubernetes project has frozen the Ingress API and recommends Gateway API for new functionality. Gateway API is the successor model and separates infrastructure ownership from application routing more explicitly.

A Gateway API path typically looks like:

Text
Internet ↓ Gateway ↓ HTTPRoute / GRPCRoute ↓ Service ↓ Pods

The main architecture advantage is not simply that Gateway API is newer. It models different responsibilities more cleanly:

  • infrastructure or platform teams can own GatewayClass and Gateway resources;
  • application teams can own Routes;
  • routes can express richer traffic behavior without provider-specific Ingress annotations.

Ingress is still valid for existing applications and environments where the chosen controller is built around it. There is no requirement to replace a working Ingress deployment immediately.

The important production rule is: do not expose every Service publicly just because Kubernetes makes exposure easy.

Most internal APIs, workers, databases, queues, and administrative components should remain private.

For the traffic-entry decision itself, use Kubernetes Load Balancer vs Ingress Controller.

NetworkPolicy is workload segmentation, not a cloud firewall

Kubernetes NetworkPolicy controls traffic to and from selected Pods at the network-policy layer.

It is useful for designs such as:

Text
frontend ↓ allowed api ↓ allowed database frontend ─X→ database

A common baseline is to start from default-deny rules and then add explicit application paths.

But two constraints matter.

First, NetworkPolicy requires enforcement by the cluster network implementation. Creating a NetworkPolicy object does not help if the networking implementation does not enforce that API.

Second, NetworkPolicy is not a replacement for:

  • VPC segmentation;
  • host or edge firewall policy;
  • application authentication;
  • authorization;
  • secrets management;
  • TLS.

Use it as one control inside a layered security model.

The implementation details—including ingress, egress, namespace selectors, DNS allowances, and rollout safety—belong in Kubernetes Network Policies for Small Teams.

Private networking belongs below Kubernetes

The cloud network and the Kubernetes network should reinforce each other.

A production pattern can look like:

Text
Internet ↓ Managed public endpoint ↓ private cloud network / VPC ├── worker node A ├── worker node B └── worker node C ↓ Kubernetes Services ↓ Pods

This structure keeps worker infrastructure private while still allowing deliberate public application entry.

It also provides a cleaner path to private adjacent services such as databases, VMs, storage systems, monitoring agents, or VPN-connected networks.

The design question is therefore not "VPC or Kubernetes networking?" The two operate at different layers.

Use the VPC to define the infrastructure trust boundary. Use Kubernetes networking resources to define workload reachability and application traffic paths inside that boundary.

Kubernetes storage begins with workload state classification

Before creating a PersistentVolumeClaim, classify the state the application actually owns.

Data typeTypical homeReason
Container imageRegistryImmutable deployment artifact
Application codeContainer image/build artifactReplaceable
Temporary cacheEphemeral storage or cache serviceRebuildable
Database recordsManaged DB or purpose-built database storageNeeds consistency and recovery controls
Shared uploadsObject storage in many architecturesDecouples files from Pod/node lifecycle
Durable filesystem dataPersistentVolumeRequires mounted filesystem semantics
Logs and metricsObservability systemShould survive individual Pods
Backup archivesSeparate recovery targetMust survive live-state failures

A useful Kubernetes architecture often puts less state inside the cluster, not more.

Stateless application tiers backed by managed databases or object storage are usually easier to scale, replace, and recover. PersistentVolumes remain appropriate when software genuinely requires mounted durable filesystem state.

PVC, PV, and StorageClass solve different parts of persistence

Kubernetes persistence is usually represented through three layers:

Text
Pod ↓ mounts PersistentVolumeClaim ↓ binds to PersistentVolume ↓ provisioned by StorageClass / CSI implementation

A PersistentVolumeClaim (PVC) expresses what storage a workload requests.

A PersistentVolume (PV) represents storage available to the cluster.

A StorageClass describes how storage is provisioned and can define provider-specific parameters, reclaim behavior, expansion support, and volume-binding behavior.

This separation is useful because a Pod can disappear while the storage resource remains available according to its lifecycle policy.

Two StorageClass decisions deserve explicit review in production:

  • reclaim policy — whether storage is deleted or retained after the claim is released;
  • volume binding mode — whether a volume is provisioned immediately or waits until the scheduler knows where the consuming Pod will run.

For topology-constrained storage, WaitForFirstConsumer can avoid provisioning a volume in a location that does not match the Pod's scheduling requirements.

For the storage-specific decision tree, continue to Kubernetes Persistent Storage: Volumes, Storage Classes, and Backups.

Persistence is not backup

A persistent volume answers:

Will the data remain when this Pod is replaced?

A backup answers:

Can we recover an earlier usable state after data loss, deletion, corruption, or a larger failure?

Those are different guarantees.

A PVC can remain healthy while the application has already:

  • deleted the wrong records;
  • overwritten customer files;
  • propagated logical database corruption;
  • encrypted data through compromised credentials;
  • changed a schema incorrectly.

That is why production state needs a recovery design outside the basic PV lifecycle.

For each stateful workload, define:

  1. what data must survive ordinary Pod replacement;
  2. what failure modes require a backup;
  3. where backups live;
  4. what RPO and RTO matter;
  5. how restore is tested;
  6. who owns the recovery decision.

If the answer is only "the volume is persistent," the recovery design is incomplete.

Design traffic and state together, but keep their failure domains separate

Use one workload matrix during architecture review:

WorkloadTraffic pathState pathRecovery model
Public stateless APIGateway/Ingress → Service → PodsExternal DB/object storageRedeploy app; restore data service separately
Private workerPrivate dependencies onlyUsually noneRecreate Pod
Stateful applicationService → PodsPVC/PVVolume + application-aware backup
Database in clusterStrictly restricted ServicePurpose-built persistent storageDatabase-consistent backup and restore
Shared file workloadApp ServicePVC or object storageStorage-specific restore strategy

This makes four architecture planes visible:

  1. Reachability — which components can connect.
  2. Exposure — which paths are public.
  3. Persistence — which state survives workload replacement.
  4. Recovery — which earlier state can be restored.

A production review should be able to answer all four for every critical workload.

How this maps to Raff Kubernetes

Raff Managed Kubernetes keeps the same responsibility boundaries visible.

Current Raff Kubernetes provides:

  • a $0 standard control plane;
  • optional three-master HA for $30/month;
  • private networking for cluster nodes;
  • a managed public endpoint with DNS and TLS;
  • node pools and autoscaling;
  • built-in monitoring and pod logs;
  • dedicated storage nodes from 10 GB to 1,000 GB at $0.08/GB-month;
  • unmetered public bandwidth up to 3 Gbps with $0 public egress fees.

The important architecture distinction is that these capabilities still solve different layers.

Private networking protects the infrastructure boundary. Kubernetes Services and routing resources control workload traffic. Dedicated storage provides persistent capacity. Application backups and restore testing remain separate recovery responsibilities.

For managed-versus-self-managed ownership, use Managed vs Self-Managed Kubernetes. For live product scope and current pricing, use Raff Kubernetes.

Production review checklist

Before putting a workload into production, verify:

Networking

  • Worker infrastructure is private unless a public node path is explicitly required.
  • Public traffic has one deliberate entry architecture.
  • Internal services are not exposed publicly without a requirement.
  • Applications use Services rather than Pod IPs.
  • DNS/service discovery behavior is understood.
  • NetworkPolicy enforcement support is confirmed before relying on policy.
  • Gateway API versus Ingress ownership is intentional.

Storage

  • Every persistent workload has a named PVC/storage owner.
  • StorageClass behavior is understood.
  • Reclaim policy matches the deletion/recovery expectation.
  • Topology and binding behavior match scheduling constraints.
  • Stateful data is not placed on a PVC merely because it can be.
  • Backup and restore are designed separately from persistence.

Recovery

  • The team knows what survives Pod loss.
  • The team knows what survives node loss.
  • The team knows what survives logical data corruption.
  • A restore path exists for business-critical state.
  • Recovery is tested, not assumed.

Final architecture recommendation

Start from the workload rather than from Kubernetes primitives.

Keep infrastructure private by default. Give replaceable Pods stable identities through Services. Use Gateway API or an existing Ingress implementation only for traffic that must enter the cluster. Add NetworkPolicy when workload segmentation is required and the network implementation enforces it.

For state, prefer external managed data services or object storage when they better match the application's needs. Use PersistentVolumes when software requires durable mounted filesystem semantics, and treat backup and restore as a separate system.

That separation produces a Kubernetes platform that is easier to scale, secure, troubleshoot, and recover.

Continue with Kubernetes Services, Ingress, and Load Balancers for traffic primitives, Kubernetes Network Policies for workload isolation, and Kubernetes Persistent Storage for stateful workload design.

Deploy Raff Kubernetes with private networking, managed traffic entry, node pools, autoscaling, and persistent storage built into the cluster platform.

Free control plane · 14-day money-back guarantee

Deploy a Cluster Now
Was this article helpful?
Serdar Tekin
Serdar Tekin
Co-Founder & CTO

Co-Founder & CTO at Raff, focused on cloud infrastructure, systems architecture, security, reliability, and production operations.

Free control plane

Get managed Kubernetes with persistent volumes, worker nodes from $9.99 a month.

CNCF-certified Kubernetes with a free control plane. Add nodes when you need them, with no egress fees.

14-day money-back guarantee

Frequently asked questions

What is Kubernetes networking?
Kubernetes networking covers Pod reachability, stable Service discovery, external traffic entry, and workload traffic controls. The cloud VPC sits underneath this as a separate infrastructure boundary.
Should new Kubernetes applications use Ingress or Gateway API?
Ingress remains stable and widely supported, but Kubernetes has frozen the Ingress API and recommends Gateway API for new functionality. Existing Ingress deployments do not need replacement solely because Gateway API exists.
What is the difference between a Kubernetes Service and Gateway API?
A Service gives a stable endpoint to changing Pods. Gateway API controls how routed traffic reaches Services through resources such as Gateway and HTTPRoute.
Do Kubernetes NetworkPolicies replace VPC firewalls?
No. NetworkPolicy controls Pod traffic when the cluster network enforces it. VPCs and firewalls operate at the infrastructure layer; application authentication and authorization operate above it.
What is Kubernetes persistent storage?
Persistent storage uses PVCs, PVs, StorageClasses, and a storage implementation to give data a lifecycle separate from an individual Pod.
Does a PersistentVolume replace a backup?
No. PersistentVolumes survive ordinary Pod replacement, but they do not protect against logical deletion, corruption, compromised credentials, or every storage failure.
How does storage work on Raff Kubernetes?
Raff Kubernetes supports dedicated storage nodes from 10 GB to 1,000 GB at $0.08/GB-month, alongside private cluster networking and a managed public endpoint with DNS and TLS.