Question 611 of 302
CKA Services and Networking Practice Question
Which component is responsible for implementing the NetworkPolicy rules?
⚠ Common exam trap
Many exam-takers confuse kube-proxy's role in service traffic with network policy enforcement, but kube-proxy only handles load balancing for Services, not the pod-to-pod access control defined by NetworkPolicy.
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
CNI plugin
NetworkPolicy rules are enforced by the Container Network Interface (CNI) plugin, not by kube-proxy or any other Kubernetes control plane component. The CNI plugin (e.g., Calico, Cilium, Weave Net) implements the actual network policy by programming iptables, eBPF, or other data-plane mechanisms to allow or deny traffic between pods based on the policy selectors and rules defined in the NetworkPolicy resource.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
CoreDNS
Why it's wrong here
CoreDNS is a DNS server that provides service discovery by resolving Kubernetes service names and pod hostnames to IP addresses. It runs as a regular pod but is not involved in the data path or in enforcing L3/L4 traffic rules. NetworkPolicy rules are implemented by the CNI plugin at the network dataplane, so CoreDNS has no role in filtering pod-to-pod traffic even though it might be selected by a policy.
- ✗
kube-controller-manager
Why it's wrong here
kube-controller-manager runs control loops for built-in controllers such as the replication controller, endpoints controller, and namespace controller. These controllers reconcile desired cluster state, but they do not inspect or filter network traffic. NetworkPolicy enforcement is a dataplane operation handled by the CNI plugin after the API server stores the policy, so the controller manager is not responsible for applying those rules.
- ✗
kube-proxy
Why it's wrong here
kube-proxy is responsible for implementing Kubernetes Service networking, including ClusterIP, NodePort, and LoadBalancer types, by programming iptables, IPVS, or similar forwarding rules. It only handles service-to-pod and external-to-service traffic, whereas NetworkPolicy governs direct pod-to-pod communication based on labels, ports, and IP blocks. Because kube-proxy's forwarding logic is separate from the CNI's policy enforcement (such as Calico's iptables or Cilium's eBPF), it does not enforce NetworkPolicy rules.
- ✓
CNI plugin
Why this is correct
The correct answer is the CNI plugin. The Container Network Interface plugin manages pod networking and, depending on the implementation (e.g., Calico, Cilium, Weave, or Antrea), also enforces NetworkPolicy by programming dataplane rules. When a NetworkPolicy is created or updated, the CNI plugin receives the pod metadata and translates the allow/deny rules into iptables, eBPF, or other forwarding constructs. Without a CNI plugin that supports NetworkPolicy, the rules are stored by the API server but have no effect on traffic.
About these practice questions
Courseiva creates original exam-style practice questions with explanations and wrong-answer analysis. It does not publish real exam questions, exam dumps, or protected exam content. Learn why practice questions differ from exam dumps →
Last reviewed: Jul 4, 2026
This CKA practice question is part of Courseiva's free CNCF certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the CKA exam.
Question Discussion
Share a tip, memory trick, or ask about the reasoning behind this question. Do not post real exam questions, leaked content, braindumps, or copyrighted exam material. Comments are moderated and may be removed without notice.
Sign in to join the discussion.