Kubernetes Networking
& Security
Explore how Kubernetes connects workloads, distributes traffic, enforces security policies and operates production cloud-native networks.
Move beyond configuration examples. Investigate packet forwarding, Container Network Interfaces, service discovery, Gateway API, eBPF networking and Kubernetes network troubleshooting through interactive engineering labs.
Investigate the Kubernetes Network
Switch between networking layers to see which components participate in traffic delivery and policy enforcement.
Select a Networking Layer
Explore how Kubernetes connects pods, exposes services and enforces network policies across worker nodes.
- Pod IP connectivity
- Service endpoint discovery
- CNI implementation behaviour
- NetworkPolicy enforcement
Five Stages. Fifteen Engineering Labs.
Progress from Kubernetes network fundamentals to production security, observability and incident investigation.
Your Kubernetes Engineering Journey
Follow a structured pathway through Kubernetes networking architecture, service traffic, eBPF networking, security policy enforcement and production troubleshooting.
Begin Your Engineering Journey
Complete engineering labs to track your progress across the five learning stages.
Five Connected Engineering Stages
Select a stage to review its labs. Completed stages are highlighted automatically as your validated lab progress increases.
Stage 1 — Networking Foundations
Investigate Kubernetes networking fundamentals and CNI architecture.
From Kubernetes Architecture to Production Engineering
Follow five connected learning stages. Explore the networking foundation, investigate service traffic, examine eBPF data-plane behaviour, enforce network security and diagnose production failures.
Explore Kubernetes networking architecture and pod connectivity.
Understand the Kubernetes network model.
Understanding Kubernetes Networking Foundations
Kubernetes provides a declarative platform for running containerised workloads, but the network connecting those workloads depends on several cooperating components: the control plane, node networking, container network interfaces and the underlying physical or virtual network.
Before investigating Services, eBPF or NetworkPolicy, engineers need to understand how pods receive network connectivity, how packets travel between worker nodes and why cluster management traffic is different from application data traffic.
The Kubernetes API server coordinates cluster management through components including kubelets and controllers.
Three Foundations of Kubernetes Networking
Cluster Management and Desired State
The API server exposes the Kubernetes API. Controllers reconcile desired and observed state, while the scheduler assigns eligible pods to nodes. Kubelets manage workloads on their nodes.
Workload-to-Workload Connectivity
Pods use network namespaces and interfaces configured through the container networking implementation. The Kubernetes network model expects pod-to-pod connectivity across nodes, subject to applicable network policy.
Implementing the Data Plane
CNI defines how container networking is configured. Implementations may use routing, encapsulation, Linux bridges, virtual interfaces or eBPF. The precise forwarding path depends on the chosen implementation.
The Kubernetes control plane manages cluster state, but it does not normally forward every application packet. Pod traffic is handled through the node and network data planes.
Distinguish API server, scheduler, controllers, kubelets and the worker node networking responsibilities.
Compare same-node forwarding with cross-node traffic and identify where addressing, routes and MTU matter.
Recognise that CNI implementations differ in forwarding mechanisms, service handling and policy support.
Three Foundation Engineering Labs
Apply the concepts through interactive investigations. Each lab will validate its own learning objectives before awarding completion.
Investigate control-plane components, worker nodes and their dependencies.
Open Lab 01 →Trace same-node and cross-node pod traffic and diagnose connectivity.
Open Lab 02 →Compare network data planes and investigate CNI design decisions.
Open Lab 03 →Kubernetes Cluster Architecture Explorer
Investigate the relationships between the Kubernetes API server, scheduler, controller manager, kubelets and worker-node workloads. Introduce faults, inspect the resulting cluster state and restore healthy operation.
Fault Injection & Diagnostics
Select the API server, scheduler, controller manager and a kubelet.
Not completedInject a control-plane incident and run a relevant diagnostic command.
Not completedRecover the failed component and verify the healthy cluster state.
Not completedInvestigate the topology, diagnose a fault and verify recovery.
Pod Networking & Packet Journey Simulator
Trace packets between Kubernetes pods, compare local and cross-node forwarding, investigate encapsulation overhead and diagnose connectivity failures using simulated packet-level evidence.
Application pod hosted on worker node 01.
Configure the Network Journey
Successfully deliver traffic between two pods on the same worker node.
Not completedSuccessfully deliver a packet between worker nodes using native routing or VXLAN encapsulation.
Not completedTrigger a routing, policy or MTU failure and inspect the resulting packet trace.
Not completedValidate local forwarding, cross-node connectivity and a diagnosed failure.
CNI Architecture & eBPF Data Plane Explorer
Compare Kubernetes CNI forwarding architectures, inspect native routing, VXLAN encapsulation and eBPF-based packet processing, then investigate simulated network failures and validate recovery.
Inject a CNI Failure
Successfully trace traffic using native routing, VXLAN and the modeled eBPF forwarding architecture.
Not completedTrigger a forwarding failure and inspect the diagnostic evidence relevant to that failure.
Not completedRestore the failed network condition and successfully trace traffic using the recovered architecture.
Not completedCompare architectures, diagnose a failure and validate recovery.
Kubernetes Networking Foundations — Engineering Milestone
Review your validated engineering progress across cluster architecture, pod networking and CNI forwarding. Complete all three labs to unlock the Networking Foundations achievement and progress to Services & Traffic Engineering.
Complete three validated engineering labs to unlock this achievement.
Stage 1 Engineering Labs
Your progress is synchronized with the unified workspace dashboard.
Explain API server, scheduler, controller manager and kubelet responsibilities and investigate control-plane failures.
Distinguish same-node and cross-node packet journeys, pod CIDR routing, encapsulation and MTU constraints.
Compare native routing, VXLAN and eBPF-based forwarding profiles, diagnose failures and validate recovery.
Stage 2 — Kubernetes Services & Traffic Engineering
Explore ClusterIP, NodePort and LoadBalancer Services, endpoint selection, Gateway API, Ingress traffic routing and Kubernetes DNS.
Kubernetes Services & Traffic Engineering
Kubernetes Services provide stable destinations for changing pod workloads. Ingress controllers and Gateway API implementations route application traffic, while CoreDNS enables service discovery. This stage investigates how these components work together, how traffic reaches application endpoints and what happens when service routing fails.
Explore ClusterIP, NodePort and LoadBalancer forwarding, backend selection, endpoint readiness and service routing failures.
Explore Service Routing →Configure host and path routing, inspect Gateway API relationships, test listener matching and diagnose application traffic failures.
Explore Gateway Routing →Investigate Kubernetes service DNS, namespace resolution, CoreDNS behaviour, endpoint discovery and DNS troubleshooting.
Explore Service Discovery →0 of 3 service engineering labs completed.
Kubernetes Service Routing Simulator
Investigate Service types, endpoint readiness and traffic forwarding. Configure the client entry point, select a Service exposure model, inject backend failures and inspect the resulting packet journey.
Configure Service Traffic
Successfully route traffic from an in-cluster client through a ClusterIP Service.
Not completedSuccessfully access a NodePort or LoadBalancer Service from an external client.
Not completedCause a Service routing failure and inspect the endpoint state that explains the failure.
Not completedValidate internal routing, external access and endpoint diagnostics.
Kubernetes Ingress & Gateway API Traffic Lab
Configure an application hostname, HTTP path, listener protocol and routing implementation. Trace the request through a simulated ingress or Gateway API data plane, inspect backend selection and diagnose common production routing failures.
Configure an Application Request
Successfully route requests to both API and Web Services using the configured rules.
Not completedDeliver an HTTPS request through a healthy Gateway listener and TLS termination.
Not completedTrigger a TLS, listener or backend routing failure, then inspect the relevant diagnostic evidence.
Not completedValidate HTTP routing, HTTPS listener access and troubleshooting.
Kubernetes DNS & Service Discovery Simulator
Investigate how application pods discover Kubernetes Services through DNS. Compare standard and headless Services, inspect namespace-aware resolution, simulate cache behaviour and diagnose CoreDNS failures.
Configure a DNS Query
Successfully resolve a ClusterIP Service using namespace-aware Kubernetes DNS.
Not completedResolve a headless Service and inspect the returned pod IP addresses rather than a virtual IP.
Not completedTrigger a DNS failure, inspect its cause and restore successful resolution.
Not completedValidate standard Services, headless discovery and DNS recovery.
Services & Traffic Engineering — Stage Achievement
Stage 2 develops the ability to investigate Kubernetes Service forwarding, HTTP application routing and DNS-based service discovery. The achievement panel evaluates the completion state of all three engineering labs.
Stage 2 Validation
Complete the three engineering labs to validate Kubernetes application traffic fundamentals.
0 of 3 engineering labs completed.
Kubernetes Services & Traffic Engineering
Complete Labs 04–06 to earn this stage achievement. Successful completion demonstrates practical familiarity with Service routing, ingress/gateway traffic and Kubernetes DNS troubleshooting.
Explore eBPF packet processing, Cilium network policy enforcement and Kubernetes network observability.
eBPF Networking & Kubernetes Observability
Modern Kubernetes networking can use eBPF programs to implement packet processing, Service load balancing, security policy enforcement and network visibility. This stage investigates how Cilium uses Linux kernel capabilities to build a programmable networking datapath, and how engineers observe and troubleshoot packet flows in production clusters.
eBPF programs execute at supported kernel attachment points. They can inspect and influence networking behaviour without requiring a conventional kernel module for each feature.
Cilium combines eBPF programs, maps, workload identities and control-plane components to implement networking and security features.
Flow visibility helps engineers investigate policy drops, unexpected endpoints, Service routing and application connectivity failures.
Trace packets through selected kernel networking hooks, Service translation, forwarding decisions and eBPF state.
Investigate the Datapath →Investigate identity-based policy enforcement, ingress and egress rules, permitted flows and policy drops.
Investigate Cilium Policy →Analyze flow events, source and destination identities, drop reasons and simulated Hubble telemetry.
Investigate Network Flows →0 of 3 eBPF engineering labs completed.
eBPF Packet Journey Simulator
Investigate packet processing through Linux kernel networking hooks and a simplified Cilium datapath. Select an ingress scenario, inspect eBPF map lookups, inject forwarding faults and trace packet verdicts.
Configure Packet Processing
Successfully trace a packet through Service lookup and backend selection.
Not completedSuccessfully investigate both XDP + TC and TC-only datapaths.
Not completedTrigger a packet drop and inspect the eBPF state explaining the failure.
Not completedValidate Service translation, kernel hooks and fault diagnosis.
Cilium Network Policy Engineering Lab
Investigate workload identity, ingress and egress policy enforcement and protocol-aware security decisions. Configure a simulated Cilium policy, test application traffic and diagnose why specific flows are allowed or denied.
Configure Security Enforcement
Permit the frontend-to-API and API-to-database application flows using their intended L4 ports.
Not completedApply a default-deny policy and confirm that an unapproved application flow is blocked.
Not completedGenerate a denied flow and inspect the security identity and policy state explaining the verdict.
Not completedValidate application allow rules, default-deny enforcement and policy diagnosis.
Kubernetes Network Observability & Hubble Flow Investigation
Investigate simulated Cilium/Hubble flow telemetry to identify forwarding behaviour, policy drops, Service backend selection and application connectivity failures. Filter network events, inspect individual flows, compare healthy and incident states, and validate a recovery.
Frontend → API: allowed. API → Database: allowed. Frontend → Database: denied.
No incident injected.
Generate & Inspect Network Events
| FLOW | SOURCE | DESTINATION | L4 | VERDICT | REASON |
|---|
Generate healthy application flows and inspect a forwarded workload communication event.
Not completedInject an API-to-database policy failure, select the dropped flow and inspect its security verdict.
Not completedCompare an incident against the healthy baseline, restore healthy traffic and confirm forwarding.
Not completedValidate flow inspection, incident diagnosis and recovery.
Stage 3 — eBPF Networking & Observability Achievement
Demonstrate competency in kernel packet processing, Cilium identity-based security and network flow investigation. Your achievement is awarded when Labs 07, 08 and 09 are completed.
Understand packet-processing hooks, eBPF map lookups, Service translation and forwarding verdicts.
Not validatedInvestigate workload identities, policy enforcement, allowed traffic and denied network flows.
Not validatedAnalyze flow telemetry, investigate incidents and validate restored application connectivity.
Not validatedFive-Stage Engineering Learning Pathway
Complete all three Stage 3 labs to unlock the Zero Trust engineering pathway.
Kubernetes Network Security & Zero Trust Architecture
Kubernetes provides networking primitives that support workload communication, but secure production environments require explicit traffic controls. This stage investigates namespace boundaries, NetworkPolicy, identity-based microsegmentation, default-deny models and secure application egress.
Select workloads with ingress and egress policies, then permit only required communications. A default-deny baseline reduces unintended lateral connectivity.
Security decisions can use workload labels and Cilium security identities, reducing dependence on changing Pod IP addresses.
Egress policies and supported gateway architectures restrict external destinations and provide greater control over outbound traffic.
Construct ingress and egress rules using Pod selectors, namespace selectors, protocols and ports. Validate policy behaviour against application flows.
Build NetworkPolicy →Investigate lateral movement, workload identity, default-deny boundaries and least-privilege application communication.
Investigate Microsegmentation →Design outbound traffic controls, investigate external destinations, simulate egress gateways and diagnose blocked connections.
Investigate Secure Egress →0 of 3 security engineering labs completed.
Kubernetes NetworkPolicy Builder & Traffic Validation Lab
Construct a Kubernetes NetworkPolicy using namespace selectors, Pod selectors, ingress or egress rules and L4 ports. Generate a simplified YAML manifest, test workload traffic and investigate the effect of default-deny enforcement.
Build & Validate a NetworkPolicy
Permit frontend → API traffic on TCP/443 using a namespace-aware ingress policy.
Not completedApply a default-deny policy and verify that unauthorized traffic is blocked.
Not completedApply an egress policy permitting API → database TCP/5432 and verify the traffic decision.
Not completedBuild ingress, default-deny and egress controls.
Zero Trust Microsegmentation & Lateral Movement Investigation
A frontend workload has been compromised. Investigate whether the attacker can reach internal application services or protected databases. Apply least-privilege network segmentation, validate legitimate traffic and compare the network's exposure before and after policy enforcement.
Configure Microsegmentation
Without network policy enforcement, the compromised frontend can attempt direct communication with the API and database. This creates unnecessary lateral network reachability.
Frontend → API TCP/443 and API → database TCP/5432 remain permitted. Direct frontend → database access is denied by the segmentation policy.
Simulate the compromised frontend in the flat network and identify an exposed database path.
Not completedBlock direct frontend-to-database traffic while retaining the approved application paths.
Not completedCompare flat and hardened network states after successfully validating application traffic.
Not completedInvestigate exposure, apply segmentation and validate the security improvement.
Secure Egress Engineering & External Connectivity Investigation
Investigate how Kubernetes workloads resolve external destinations, enforce outbound security policies and route approved traffic through an egress gateway. Diagnose DNS failures, policy denials and source NAT behaviour while preserving legitimate SaaS access.
Configure & Trace Outbound Traffic
Investigate a destination without a valid DNS record and identify the resolution failure.
Not completedPermit the approved SaaS endpoint while denying an unapproved external destination.
Not completedRoute approved outbound traffic through the egress gateway and verify its translated source IP.
Not completedDiagnose DNS, enforce policy and validate gateway SNAT.
Stage 4 — Zero Trust Security Engineering Achievement
Demonstrate practical knowledge of Kubernetes NetworkPolicy, microsegmentation, lateral movement prevention, DNS-aware egress controls and secure outbound gateway routing. Complete Labs 10–12 to earn the Stage 4 engineering milestone.
Construct ingress and egress policies, configure workload selectors and validate permitted and denied traffic.
Not validatedInvestigate lateral reachability, protect sensitive workloads and preserve least-privilege application dependencies.
Not validatedDiagnose DNS failures, restrict outbound destinations and investigate gateway-based source NAT.
Not validatedFive-Stage Kubernetes Engineering Pathway
Complete all three Stage 4 labs to unlock production incident investigation.
Production Kubernetes Network Troubleshooting
Kubernetes networking incidents rarely belong to a single component. A failed application request may involve Pod addressing, CNI forwarding, DNS, Service translation, EndpointSlices, security policy or an unhealthy backend. This final stage develops a structured, evidence-driven approach to diagnosing failures across the complete packet path.
Application clients report intermittent connection failures. Determine which networking layer is responsible before proposing remediation.
Identify affected workloads, namespaces, nodes, services and traffic directions.
Inspect Pod state, routes, DNS responses, Service endpoints, policies and flow telemetry.
Compare healthy and failed packet paths to identify the failing component.
Apply the smallest appropriate correction and verify end-to-end connectivity.
Diagnose cross-node Pod traffic, CNI forwarding state and routing or encapsulation failures.
Open Lab 13 → Not completedTrace client-to-Service traffic, inspect EndpointSlices and investigate DNS or backend failures.
Open Lab 14 → Not completedCorrelate CNI, Service, DNS, security and observability evidence in a complex production-style incident.
Open Lab 15 → Not completedComplete Labs 13–15 to demonstrate end-to-end Kubernetes network troubleshooting across infrastructure, Service routing, security policy and observability.
Pod Connectivity Investigation & CNI Routing Troubleshooting
Two Kubernetes worker nodes host application Pods on separate Pod CIDRs. Investigate failed cross-node connectivity, inspect CNI forwarding state, identify routing or encapsulation faults and validate recovery after remediation.
Diagnose Cross-Node Connectivity
Cross-node Pod communication fails. The underlying forwarding fault must be identified through diagnostics.
Recovery has not yet been validated. Select the correct remediation and repeat the packet test.
Inspect Pod addressing and the cross-node forwarding state before remediation.
Not completedSelect a remediation matching the observed CNI, routing or underlay failure.
Not completedRepeat the Pod-to-Pod packet trace and verify end-to-end connectivity.
Not completedCollect evidence, repair the fault and validate recovery.
Kubernetes Service Failure Diagnosis & EndpointSlice Investigation
An application Service exists and has a ClusterIP, but clients cannot consistently reach its backends. Investigate DNS resolution, Service selectors, EndpointSlice readiness, targetPort configuration and Pod health. Restore the correct Service-to-backend forwarding path using diagnostic evidence.
Diagnose Service Forwarding
Service delivery fails. Inspect Service configuration, DNS, EndpointSlices and backend health.
Recovery has not yet been validated. Select the correct remediation and repeat the Service request.
Inspect the Service object and the relevant EndpointSlice, DNS or backend evidence.
Not completedCorrect the selector, readiness state, targetPort or Service DNS reference.
Not completedTrace the repaired request and verify that traffic reaches a healthy backend.
Not completedCollect evidence, repair the Service and validate recovery.
Production Kubernetes Network Incident Capstone
A production application is experiencing widespread connectivity failures. Multiple faults have been introduced across the cluster. Investigate DNS, Service endpoints, CNI forwarding and security policy enforcement. Correlate diagnostic evidence, apply the correct remediations and validate complete application recovery.
Production Incident Timeline
Investigate the Multi-Fault Outage
DNS reference incorrect. Service endpoints unavailable. Cross-node CNI forwarding broken. NetworkPolicy denies application traffic.
No remediation applied. All four faults remain active.
Investigate DNS, Service, CNI and security policy before applying repairs.
Not completedCorrect DNS, Service and CNI forwarding failures using diagnostic evidence.
Not completedCorrect the restrictive security policy while preserving controlled access.
Not completedConfirm DNS, endpoints, CNI forwarding and policy all permit application delivery.
Not completedFour engineering objectives must be validated.
Stage 5 — Production Kubernetes Troubleshooting Achievement
Demonstrate practical troubleshooting capability across Pod connectivity, CNI forwarding, Service routing, EndpointSlice readiness, DNS, NetworkPolicy and production incident recovery. Complete Labs 13–15 to unlock the final engineering achievement.
Investigate cross-node Pod connectivity, forwarding routes, overlay tunnels, MTU and underlay restrictions.
Not validatedDiagnose DNS, Service selectors, EndpointSlice readiness, targetPort mismatches and backend health.
Not validatedCorrelate multiple networking failures, collect evidence, apply targeted remediation and validate recovery.
Not validatedComplete Kubernetes Engineering Pathway
Complete the final three troubleshooting labs to validate your production engineering competencies.
Kubernetes Networking & Security — Final Engineering Achievement
Your complete Kubernetes engineering pathway brings together cluster networking, Service routing, DNS, CNI architecture, eBPF, Cilium, Zero Trust security and production troubleshooting. Track all 15 labs, validate five learning stages and unlock your final workspace achievement.
Overall Workspace Progress
Progress is synchronized with the interactive labs throughout this workspace. Complete each lab's engineering objectives and its completion record will automatically update this dashboard.
Five-Stage Engineering Learning Pathway
Architecture, Pod traffic and CNI fundamentals.
0 / 3 LabsService routing, Gateway API and DNS discovery.
0 / 3 LabsPacket processing, Cilium policy and flow analysis.
0 / 3 LabsNetworkPolicy, microsegmentation and secure egress.
0 / 3 LabsPod, Service and multi-fault incident investigations.
0 / 3 LabsAll 15 Engineering Labs
Pod addressing, cluster topology and CNI datapaths.
Not validatedClusterIP, Ingress, Gateway API and DNS.
Not validatedCilium policy, packet paths and flow investigation.
Not validatedPolicy isolation, microsegmentation and egress control.
Not validatedEvidence-driven diagnosis and incident recovery.
Not validatedComplete all 15 engineering labs across the five learning stages to unlock your final Network Insight workspace achievement.