Cilium-Associate Cilium Certified AssociateCCA Questions and Answers

Technical explanation

Option C has the correct Cilium policy structure. It selects pods labeled app: frontend , creates an egress rule with a valid CIDR entry, and combines that destination constraint with toPorts , port 8888 , and protocol TCP . Because the CIDR and port restriction are in the same egress rule, traffic must meet both conditions.

Option A uses an unsupported address-range structure with from and to fields rather than CIDR notation. Option B initially resembles the correct form but contains an additional malformed ports item at the egress-rule level. Option D uses unsupported action: allow and action: deny fields inside toPorts ; Cilium allow and deny behavior is expressed through policy sections such as egress and egressDeny , not per-port action properties.

The item is nevertheless defective. The prose and examples indicate 192.168.9.0/24 , while all displayed CIDR-based options specify 192.168.0.0/24 ; the source text itself shows the corrupted 192.168.e.e/24 . If 192.168.9.0/24 is authoritative, none of the exhibits permits the stated example. The supplied key B is structurally incorrect under the displayed manifests.

Official references

Cilium Layer 3 and CIDR Policies

Study Guide topic: CIDR selectors, Layer 4 ports, and rule composition.

Technical explanation

The policy attaches an HTTP Layer 7 rule to port 80 but omits protocol: TCP from the associated ports entry. HTTP policy is layered on a Layer 4 TCP rule, and the documented Cilium form explicitly identifies TCP before specifying the HTTP method and path. D therefore identifies the configuration defect intended by the question.

The cross-namespace source selection is valid. The policy resides in namespace back and selects backend pods there. Its fromEndpoints selector explicitly includes k8s:io.kubernetes.pod.namespace: blog , allowing it to select matching app-frontend endpoints in that other namespace. Option A is consequently not an error.

The k8s: source prefix in k8s:app.kubernetes.io/name is also valid Cilium label syntax and identifies the Kubernetes label source, making B false. Port 80 may be used in a Cilium policy; the privileged-port restriction concerns which processes may bind low-numbered ports under operating-system permissions, not whether a network policy can reference them.

The corrected port entry should contain port: "80" together with protocol: TCP .

Official references

Cilium Layer 7 Policies , Kubernetes Constructs in Cilium Policy

Study Guide topic: Combining Layer 4 port rules with Layer 7 HTTP policies.

Technical explanation

The Cilium Operator handles IP address management responsibilities in IPAM modes that require cluster-wide or cloud-integrated allocation. Current documentation identifies the operator as responsible for IPAM in Azure IPAM, AWS ENI, and cluster-scope mode. Cloud-specific operators populate the appropriate allocation information in CiliumNode resources, after which node-local agents allocate addresses to endpoints from the available ranges.

The phrase “when available” is important because responsibilities vary by IPAM mode. Under Kubernetes host-scope IPAM, Kubernetes allocates each node’s PodCIDR, and the Cilium agent consumes that range from the Kubernetes Node object. Nevertheless, among the supplied components, the operator is the component specifically associated with centralized IPAM requests and allocation management.

The Cilium agent implements each node’s datapath and endpoint lifecycle but is not the general cluster-wide IPAM answer intended here. Cilium API Server is not the documented allocation component. The misspelled Cilium CNIPIugin refers to the CNI plugin, which requests networking setup when a pod is created but does not replace the operator’s IPAM responsibilities.

Official references

Cilium Operator , Cilium IP Address Management

Study Guide topic: Cilium Operator responsibilities and IPAM modes.

Technical explanation

Cilium derives a workload’s security identity from its security-relevant labels. Network policies then refer to workload characteristics such as application, role, environment, namespace, or service account rather than depending exclusively on transient pod IP addresses. The identity is associated with traffic in the Cilium datapath and validated when policy is enforced. This makes B the accurate description.

The identity is not limited to a single pod. Endpoints that have the same set of identity-relevant labels can share the same numeric security identity, including endpoints located on different cluster nodes. This reduces policy-map growth and allows policy to scale with logical application groups rather than with the number of pod addresses. Namespace information is normally among the labels used to derive identity, but that does not make an identity inherently “tied to a single namespace” as option A states.

Options C and D invert Cilium’s design. IP addresses remain necessary for packet delivery, but they are not the primary security identifier for Cilium-managed workloads. Pods can be recreated and assigned new addresses while retaining the same relevant labels and therefore the same security intent. Decoupling identity from addressing is precisely what improves scalability and operational stability.

Official references

Cilium Terminology and Identity ; Introduction to Cilium and Hubble .

Study Guide topic: Architecture.

Technical explanation

Hubble obtains its visibility from Cilium’s eBPF datapath, and the Hubble Server is embedded in the Cilium agent. Hubble therefore cannot provide its normal flow-observability capabilities as a standalone installation without Cilium, eliminating B.

CNI chaining allows Cilium to coexist with a supported existing CNI. The original plugin continues to supply base connectivity and IP address management, while Cilium attaches eBPF programs to the created network devices. Those programs provide visibility, policy enforcement, and other Cilium functionality. Hubble can then be enabled on top of the chained Cilium deployment. This approach avoids an immediate, disruptive replacement of the production cluster’s networking layer and is consequently the best answer.

Options C and D could be appropriate in broader migration projects, particularly when a current CNI is incompatible with chaining or when full native-Cilium functionality is required. However, both imply substantially more workload movement or cutover activity than the stated objective of minimizing downtime.

Compatibility, chaining mode, current CNI behavior, kernel requirements, and feature limitations must still be validated before production rollout.

Official references

Cilium CNI Chaining , Hubble Internals , Troubleshooting Hubble

Study Guide topic: Hubble prerequisites, CNI chaining, and production adoption.

Technical explanation

The host entity represents the local node on which the selected Cilium endpoint resides. It also includes processes and containers using the local host network namespace. Therefore, A reproduces the official entity definition accurately.

The remote-node entity does not represent arbitrary unmanaged endpoints. It represents hosts other than the local node across the local cluster and connected clusters, including host-networked containers on those nodes. Unmanaged endpoints instead have the reserved unmanaged identity.

Option C gives the definition of the separate kube-apiserver entity, not cluster . The cluster entity is the logical collection of endpoints and reserved identities inside the local cluster, including Cilium-managed endpoints, unmanaged local endpoints, hosts, remote nodes, health, ingress, initialization, and kube-apiserver identities. Current documentation separately provides a cluster-mesh entity for endpoints in connected clusters.

Option D confuses all with world . world represents endpoints outside the cluster. all covers all identities and is not simply equivalent to the IPv4 CIDR 0.0.0.0/0 , particularly in identity-aware, node, and IPv6 contexts.

Official references

Cilium Layer 3 Policy Entities , Cilium Reserved Identities

Study Guide topic: Reserved entities and identity-based Layer 3 policies.

Technical explanation

Masquerading performs source network address translation for qualifying traffic that leaves the cluster. Because pod addresses are often private and not routable by the external network, Cilium replaces the pod’s source address with an address belonging to the egress node. Return traffic can then reach that node, which reverses the translation and delivers the response to the originating pod. B correctly summarizes this behavior.

Masquerading is a form of SNAT, not DNAT. DNAT modifies the destination address, commonly to direct incoming traffic toward another endpoint, so C is incorrect.

Cilium documents its eBPF-based masquerading implementation as the more efficient implementation. The iptables version is the legacy alternative, making A false. Conversely, eBPF masquerading depends on appropriate kernel eBPF capabilities and Cilium’s BPF NodePort functionality. It cannot be assumed to work on every kernel version, so D is false. The legacy iptables implementation is the mode documented as broadly working across kernel versions.

Cilium can exclude natively routable CIDRs from masquerading, and administrators may configure separate IPv4 and IPv6 masquerading behavior.

Official references

Cilium Masquerading , Cilium System Requirements

Study Guide topic: SNAT, native-routing exclusions, and eBPF versus iptables masquerading.

Technical explanation

A cluster-wide requirement is best implemented with CiliumClusterwideNetworkPolicy , whose correct resource spelling is CiliumClusterwideNetworkPolicy . Unlike a namespaced CiliumNetworkPolicy , this Cilium CRD is non-namespaced and can select endpoints across the entire cluster.

To deny external ingress for every Cilium-managed pod, a cluster-wide policy can use an empty endpointSelector and an ingressDeny rule selecting the world entity. Cilium defines world as network endpoints outside the cluster. An alternative allow-list construction can permit only the cluster entity, thereby excluding external sources, but an explicit deny rule usually communicates the requirement more directly.

A standard Kubernetes NetworkPolicy and a CiliumNetworkPolicy are namespaced, requiring repeated resources in every applicable namespace. CiliumGlobalPolicy is not a valid Cilium resource type. Although the option capitalizes “Wide” differently from the actual kind, D unmistakably identifies the intended cluster-scoped policy.

Official references

Cilium Deny Policies , Cilium Network Policy Types

Study Guide topic: Cluster-scoped policies, external traffic, and reserved entities.

Technical explanation

The official IPAM documentation expressly states that the safest way to change IPAM mode is to install a fresh Kubernetes cluster using the required new IPAM configuration. A live cluster already contains allocated workload addresses, node routing state, Cilium endpoint state, service state, and potentially cloud-provider resources that depend on the active allocator. Replacing the allocator in place can invalidate these assumptions and cause persistent connectivity disruption rather than merely a short agent restart.

Updating a Kubernetes Node object does not generally convert Cilium’s IPAM mode. The responsible resource and allocation behavior depend on the selected mode: Kubernetes host-scope IPAM, cluster-pool IPAM, multi-pool IPAM, CRD-backed modes, and cloud-specific allocators manage address information differently. Restarting agents after changing a configuration value likewise does not constitute a safe migration plan, because existing endpoints and routes may retain state created under the former allocator.

Cilium advises against changing the IPAM mode of an existing cluster unless a specifically documented migration procedure applies. The currently documented exception is migration from cluster-pool IPAM to multi-pool IPAM. As the question provides no such constrained scenario, D is the unambiguously safest answer.

Official references

IP Address Management .

Study Guide topic: Installation and Configuration.

Technical explanation

The exhibit records connections originating from default/test and directed to default/test2 , eliminating B and C because those choices reverse the initiating workload. For destination port 80, the flow shows the TCP three-way handshake—SYN, SYN-ACK, and ACK—followed by bidirectional packets with ACK/PSH flags and an orderly FIN exchange. This is the pattern of a successfully established request and response, so the first curl operation succeeded.

The later connection targets port 8080. Hubble records a SYN from test followed by an ACK, RST response from test2 . A reset returned immediately after the connection attempt indicates that the destination rejected or could not accept the connection, commonly because no process was listening on that port. It is not shown as a policy drop; both entries carry the FORWARDED verdict. Thus the network delivered the packets, but the TCP connection itself failed.

Option D is the only choice matching a successful request from test to port 80 and a failed request from test to port 8080. Its displayed IP strings contain source-document transcription defects, but its workload direction, ports, and outcomes match the exhibit.

Official references

Inspecting Network Flows with the CLI ; Troubleshooting with Hubble .

Study Guide topic: Network Observability.

Technical explanation

Cilium derives an endpoint’s security identity from its security-relevant labels rather than from its current IP address. When multiple endpoints possess the same relevant label set, they receive and share the same numeric security identity. This enables policies to follow an application as pods are recreated, rescheduled, or scaled across nodes.

In Kubernetes, the Cilium agent obtains workload metadata through the Kubernetes API and associates the pod’s labels with the corresponding Cilium endpoint. Identity allocation converts the relevant label set into a cluster-wide identity. Policy enforcement then matches that identity in the eBPF datapath instead of depending exclusively on short-lived pod addresses.

Option A incorrectly makes the IP address the source of identity and says that identities cannot be shared. Option B incorrectly identifies annotations as the identity foundation. Annotations may configure behavior, but Cilium’s security model is label-based. Option D is also incorrect because operators do not ordinarily assign each pod’s numeric security identity manually. Identity allocation and lifecycle management are automatic.

Official references

Cilium Terminology and Identities , Limiting Identity-Relevant Labels

Study Guide topic: Label-derived identities and identity-based policy enforcement.

Technical explanation

The intended answer is A because API request limiting corresponds to rate limiting, which Cilium identifies as a core Layer 7 traffic-management capability. Cilium combines its eBPF datapath with Envoy for application-layer processing. The official Service Mesh documentation expressly includes rate limiting among the functions that must understand protocols such as HTTP, REST, gRPC, and WebSocket. It is therefore not merely packet-rate policing at Layer 3 or Layer 4; it can be applied with application-protocol context.

However, this question is no longer valid as a strict single-answer item. Current Cilium documentation also describes proxy-based Layer 7 load balancing as useful for gRPC and provides an Envoy-backed implementation for Kubernetes Services. Consequently, option C is also supportable under the current product documentation, although the feature is identified as beta. API authorization and fault-delay injection are not presented as equivalent first-class Cilium Service Mesh use cases in the cited feature overview.

For certification-bank purposes, retain A as the intended answer, but revise option C or qualify it to restore a unique correct choice.

Official references

Service Mesh ; Proxy Load Balancing for Kubernetes Services .

Study Guide topic: Service Mesh.

Technical explanation

Cilium tunnel mode supports VXLAN and Geneve encapsulation. In this routing model, Cilium nodes form an overlay mesh, and traffic exchanged between nodes is carried inside UDP-encapsulated packets. VXLAN is the default tunnel protocol and normally uses UDP port 8472. Geneve is the alternative and normally uses UDP port 6081. Operators select the protocol through the tunnel-protocol configuration setting, whose documented values are vxlan and geneve .

Encapsulation reduces the requirements placed on the underlying network. The underlay only needs to provide IP connectivity between the Kubernetes nodes and permit the selected UDP tunnel port. It does not need to learn or route individual PodCIDRs. Cilium also uses the tunnel metadata to carry information such as the source security identity, avoiding an additional identity lookup on the receiving node.

MPLS, OTV, STT, and EVPN are not supported values for Cilium’s tunnel-protocol setting. EVPN may be used in broader data-center network designs, and MPLS is a carrier-routing technology, but neither is a Cilium overlay encapsulation choice. Therefore, B is the only supported pair.

Official references

Cilium Routing ; System Requirements .

Study Guide topic: Architecture.

Technical explanation

C accurately describes eBPF host-routing. In a conventional datapath, packets may traverse substantial portions of the host networking stack and its iptables hooks even when Cilium performs routing decisions with eBPF. eBPF host-routing takes a more direct datapath, bypassing iptables and the upper host stack while providing a faster transition between the host and pod network namespaces. This reduces processing and context-switching overhead and can improve throughput and latency.

Option A describes load-balancing behavior rather than host routing. Backend distribution is implemented through Cilium’s service load-balancer maps and algorithms. Host routing can improve the path used by resulting packets, but it does not itself guarantee even backend selection.

Option B is the description of BIG TCP. BIG TCP increases the size of internal GSO and GRO packets to reduce stack traversal. Although BIG TCP requires eBPF host-routing in supported Cilium configurations, the two are distinct features.

Option D is overly specific and does not define the feature. Host routing optimizes compatible pod traffic generally, subject to kernel, kube-proxy-replacement, masquerading, netfilter, encryption, and integration constraints.

Official references

Cilium eBPF Host-Routing

Study Guide topic: eBPF host-routing, host-stack bypass, veth traversal, and performance.

Technical explanation

Hubble is Cilium’s integrated observability layer and consumes flow events produced by Cilium’s eBPF datapath and embedded Hubble servers. The Hubble CLI is only a client; downloading its binary does not install a standalone datapath or create flow data on a cluster that lacks Cilium. Option B is therefore the operation that is not possible.

The other approaches represent recognized Cilium deployment or migration models. A direct migration can replace the CNI configuration and recycle workloads or nodes, although a naive cluster-wide transition can disrupt connectivity. CNI chaining allows Cilium to operate with another CNI: the existing plugin continues to provide basic connectivity and IP address management, while Cilium attaches eBPF programs to the created interfaces to provide visibility, policy, and other functions. Cilium also documents migration through dual overlays. In that model, the old and new networks coexist temporarily, nodes are moved in a controlled sequence, and workloads attached to either overlay retain connectivity when the documented addressing and routing requirements are met.

The supplied bank incorrectly marks A. The verified answer is B because Hubble requires Cilium-managed observability data.

Official references

Setting up Hubble Observability ; CNI Chaining ; Migrating a cluster to Cilium .

Study Guide topic: Installation and Configuration.