Skip to main content
Ameerpet, Hyderabad · Classroom & live online
Cloud Soft Solutions

CKNE Certified Kubernetes Network Engineer Exam Guide 2026: 5 Domains, CNI, CoreDNS, Gateway API, Network Policies, 8-Week Plan and 15 Questions

CKNE, the Linux Foundation and CNCF's hands-on Kubernetes networking exam: 2 hours, performance-based, US$445, one retake and two Killer.sh attempts, valid 2 years. The five domains with weights, a pod-to-service troubleshooting path, NetworkPolicy, Gateway API and CoreDNS examples, an 8-week plan and 15 practice questions.

CKNE Certified Kubernetes Network Engineer exam guide 2026, Cloud Soft Solutions
Last updated · 6 min read · 1,357 words

CKNE Certified Kubernetes Network Engineer exam guide 2026, Cloud Soft Solutions

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)

ItemDetail
FormatOnline, proctored, performance-based (tasks in a remote Linux desktop with terminal and web interfaces)
Duration2 hours
LevelIntermediate; no formal prerequisites, but CKA-level skills are assumed
PriceUS$445 exam only; US$625 with an annual THRIVE-ONE subscription; US$645 with the Certification Pathway
IncludesOne retake; two Killer.sh simulator attempts (17 questions each, 36 hours of access)
Validity2 years
Eligibility12 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

DomainWeightCompetencies (from the Linux Foundation)
Service Networking and DNS25%L4 Services; kube-proxy and CNI alternatives; customising CoreDNS; troubleshooting Service traffic; endpoint availability; Gateway API (Gateway, HTTPRoute)
Network Security and Policy25%NetworkPolicies; node- and pod-level encryption; TLS certificates for the Gateway API; pod-level authentication and authorisation
Advanced Traffic Management20%Optimising LLM traffic; routing to expose networks; egress gateways; cross-cluster service discovery and load balancing
Core Infrastructure and CNI15%Installing and configuring CNI plugins; IPAM and pod CIDRs; iptables, ip and tcpdump; pod-to-pod and DNS troubleshooting; multi-interface pods
Observability15%Network health metrics; end-to-end tracing; auditing traffic with logs

A troubleshooting path for "pod can't reach service"

  1. DNS: kubectl exec -it client -- nslookup web.shop.svc.cluster.local; check the CoreDNS pods, their logs and the Corefile ConfigMap.
  2. Service and endpoints: kubectl get svc web -n shop -o wide and kubectl get endpointslices -n shop -l kubernetes.io/service-name=web. No endpoints usually means a selector mismatch or pods that aren't Ready.
  3. 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.
  4. Policy: kubectl get networkpolicy -A. One policy selecting a pod makes it default-deny in that direction.
  5. Packets: on the node, ip route, ip addr, iptables-save | grep web and tcpdump -i any port 8080.
  6. 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

WeekFocus
1Linux networking refresh: namespaces, veth, bridges, routes, iptables, tcpdump; Kubernetes networking model
2CNI: install and switch plugins in kind; IPAM, pod CIDRs, Multus for multi-interface pods
3Services: ClusterIP, NodePort, LoadBalancer, headless; EndpointSlices; readiness; kube-proxy modes and eBPF replacements
4CoreDNS: Corefile, stub domains, debugging; Gateway API Gateways and HTTPRoutes
5Network policies (Kubernetes and CNI-specific); default deny; DNS egress gotchas
6Encryption: WireGuard/IPsec node encryption, mTLS with a service mesh, cert-manager for Gateway TLS
7Advanced traffic: egress gateways, multi-cluster service discovery, routing for AI inference workloads
8Observability: 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

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.

Share𝕏inf✉
EnrollWhatsAppCall us