
CKNE (Certified Kubernetes Network Engineer) is the Linux Foundation and CNCF's intermediate, hands-on certification for Kubernetes networking. CKA proves you can run a cluster. CKNE goes deeper into how packets move: CNI plugins and IPAM, Services and kube-proxy alternatives, CoreDNS, the Gateway API, egress gateways, multi-cluster service discovery, network policies, encryption, TLS and mTLS, and network observability. It even covers routing traffic for LLM inference. It suits DevOps, SRE and network engineers who troubleshoot the "pod can't reach service" tickets that every Kubernetes team gets.
This guide follows the official Linux Foundation exam page. It covers the exam facts, the five domains with weights, a troubleshooting path, manifests to practise, an 8-week plan and 15 original practice questions.
Quick facts (Linux Foundation, November 2026)
| Item | Detail |
|---|---|
| Format | Online, proctored, performance-based (tasks in a remote Linux desktop with terminal and web interfaces) |
| Duration | 2 hours |
| Level | Intermediate; no formal prerequisites, but CKA-level skills are assumed |
| Price | US$445 exam only; US$625 with an annual THRIVE-ONE subscription; US$645 with the Certification Pathway |
| Includes | One retake; two Killer.sh simulator attempts (17 questions each, 36 hours of access) |
| Validity | 2 years |
| Eligibility | 12 months to schedule and take the exam |
Read the official CKNE exam page, including the list of tools featured in the exam.
Domains and weights
| Domain | Weight | Competencies (from the Linux Foundation) |
|---|---|---|
| Service Networking and DNS | 25% | L4 Services; kube-proxy and CNI alternatives; customising CoreDNS; troubleshooting Service traffic; endpoint availability; Gateway API (Gateway, HTTPRoute) |
| Network Security and Policy | 25% | NetworkPolicies; node- and pod-level encryption; TLS certificates for the Gateway API; pod-level authentication and authorisation |
| Advanced Traffic Management | 20% | Optimising LLM traffic; routing to expose networks; egress gateways; cross-cluster service discovery and load balancing |
| Core Infrastructure and CNI | 15% | Installing and configuring CNI plugins; IPAM and pod CIDRs; iptables, ip and tcpdump; pod-to-pod and DNS troubleshooting; multi-interface pods |
| Observability | 15% | Network health metrics; end-to-end tracing; auditing traffic with logs |
A troubleshooting path for "pod can't reach service"
- DNS:
kubectl exec -it client -- nslookup web.shop.svc.cluster.local; check the CoreDNS pods, their logs and the Corefile ConfigMap. - Service and endpoints:
kubectl get svc web -n shop -o wideandkubectl get endpointslices -n shop -l kubernetes.io/service-name=web. No endpoints usually means a selector mismatch or pods that aren't Ready. - Pod-to-pod: curl the pod IP directly. If that works but the Service doesn't, look at kube-proxy (iptables or IPVS rules) or the CNI's service implementation.
- Policy:
kubectl get networkpolicy -A. One policy selecting a pod makes it default-deny in that direction. - Packets: on the node,
ip route,ip addr,iptables-save | grep webandtcpdump -i any port 8080. - Observe: use flow logs (for example Hubble) or metrics and traces to find drops and latency.
Manifests to practise
Default deny plus one allowed path (remember DNS egress):
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: { name: default-deny, namespace: shop }
spec:
podSelector: {}
policyTypes: [Ingress, Egress]
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: { name: frontend-to-api, namespace: shop }
spec:
podSelector: { matchLabels: { app: api } }
ingress:
- from: [ { podSelector: { matchLabels: { app: frontend } } } ]
ports: [ { port: 8080, protocol: TCP } ]
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: { name: allow-dns, namespace: shop }
spec:
podSelector: {}
policyTypes: [Egress]
egress:
- to: [ { namespaceSelector: { matchLabels: { kubernetes.io/metadata.name: kube-system } } } ]
ports: [ { port: 53, protocol: UDP }, { port: 53, protocol: TCP } ]
Gateway API with TLS and a weighted split:
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata: { name: web-gw, namespace: shop }
spec:
gatewayClassName: example
listeners:
- name: https
protocol: HTTPS
port: 443
hostname: shop.example.com
tls:
mode: Terminate
certificateRefs: [ { name: shop-tls } ] # a TLS Secret, e.g. from cert-manager
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: { name: web, namespace: shop }
spec:
parentRefs: [ { name: web-gw } ]
hostnames: [ shop.example.com ]
rules:
- matches: [ { path: { type: PathPrefix, value: / } } ]
backendRefs:
- { name: web-v1, port: 80, weight: 90 }
- { name: web-v2, port: 80, weight: 10 }
A custom CoreDNS forward for an internal domain (added to the Corefile ConfigMap):
corp.internal:53 {
errors
cache 30
forward . 10.0.0.10
}
8-week study plan
| Week | Focus |
|---|---|
| 1 | Linux networking refresh: namespaces, veth, bridges, routes, iptables, tcpdump; Kubernetes networking model |
| 2 | CNI: install and switch plugins in kind; IPAM, pod CIDRs, Multus for multi-interface pods |
| 3 | Services: ClusterIP, NodePort, LoadBalancer, headless; EndpointSlices; readiness; kube-proxy modes and eBPF replacements |
| 4 | CoreDNS: Corefile, stub domains, debugging; Gateway API Gateways and HTTPRoutes |
| 5 | Network policies (Kubernetes and CNI-specific); default deny; DNS egress gotchas |
| 6 | Encryption: WireGuard/IPsec node encryption, mTLS with a service mesh, cert-manager for Gateway TLS |
| 7 | Advanced traffic: egress gateways, multi-cluster service discovery, routing for AI inference workloads |
| 8 | Observability: metrics, tracing, flow and access logs; two Killer.sh sessions; book the exam |
15 practice questions with answers
These are original questions written for this guide, not exam questions.
1. What does a CNI plugin do?
Gives each pod a network interface and IP address and connects it to the cluster network.
2. Where are pod IP ranges usually defined per node?
In the node's pod CIDR, allocated by the controller manager or by the CNI's IPAM.
3. Which tool attaches a second network interface to a pod?
Multus (a meta-CNI plugin).
4. A Service has no endpoints. What are two likely causes?
The selector doesn't match pod labels, or the pods aren't Ready.
5. What does a headless Service (clusterIP: None) return in DNS?
The individual pod IPs instead of one virtual IP.
6. What is the full DNS name of Service "web" in namespace "shop"?web.shop.svc.cluster.local (with the default cluster domain).
7. Which ConfigMap holds the CoreDNS configuration?coredns in kube-system (the Corefile).
8. Which Gateway API resource attaches routing rules to a Gateway?
An HTTPRoute (or another Route type) through parentRefs.
9. How do you send 10% of traffic to a new version with the Gateway API?
Use weighted backendRefs in the HTTPRoute.
10. After applying a default-deny egress policy, name resolution fails. Why?
DNS traffic to CoreDNS on port 53 is now blocked; add an egress rule for it.
11. Are Kubernetes NetworkPolicies enforced without a supporting CNI?
No. The CNI plugin must implement them.
12. Name two ways to encrypt pod traffic between nodes.
CNI transparent encryption with WireGuard or IPsec, or mTLS from a service mesh.
13. What does an egress gateway give you?
A fixed, known exit point and source IP for traffic leaving the cluster, so external firewalls can allow it.
14. Which Linux tool shows packets arriving on a node interface?tcpdump.
15. Which signal finds where latency is added across several services?
Distributed tracing.
Before and after CKNE
- Start with KCNA and CKAD, plus CKA-level administration.
- Go deeper on the data plane with Cilium CCA and Istio ICA; on platforms with CNPE.
- Learn it hands-on in our Kubernetes course and GKE course; see live Kubernetes and DevOps jobs.
Cloud Soft Solutions in Ameerpet, Hyderabad teaches Kubernetes, cloud networking and platform engineering with real-time projects. See the APEX program and all courses.
📞 Call +91 96660 19191 · WhatsApp · Flat No. 513, 5th Floor, Nilagiri Block, Aditya Enclave, Ameerpet, Hyderabad
Frequently Asked Questions
What is CKNE?
The Certified Kubernetes Network Engineer, an intermediate, performance-based Linux Foundation and CNCF certification for Kubernetes networking.
How long is the CKNE exam and what does it cost?
2 hours, and US$445 for the exam only.
Do I need CKA before CKNE?
It isn't required, but the Linux Foundation says CKNE assumes CKA-level skills and recommends CKA first or alongside.
Which CKNE domains have the most weight?
Service Networking and DNS, and Network Security and Policy, at 25% each.
Does CKNE include practice exams?
Yes, two Killer.sh simulator attempts with 17 questions each, plus one exam retake.
How long is CKNE valid?
2 years.



