Pass the Linux Foundation Cloud & Containers Cilium-Associate Questions and answers with CertsForce

Technical explanation

BIG TCP permits the Linux networking stack to process packets larger than the traditional approximately 64-KiB limit represented by the IP length field while the packets remain inside the host. IPv6 BIG TCP uses a temporary Hop-by-Hop header carrying the larger internal length, while IPv4 BIG TCP sets tot_len to zero and uses the socket buffer length internally. Before transmission, packets are segmented into sizes suitable for the physical network. C therefore identifies the problem BIG TCP addresses.

Option A is false because Cilium’s documentation explicitly states that BIG TCP does not require network-interface MTU changes. The larger objects exist inside the software networking stack and are segmented before appearing on the wire.

Option B reverses the intended performance effect. Larger internal GSO and GRO packets reduce repeated stack traversal, lowering CPU utilization and generally improving throughput and latency. Option D is also false: Generic Segmentation Offload and Generic Receive Offload are fundamental to BIG TCP’s operation. Cilium increases their maximum sizes when BIG TCP is enabled. The source mentions TSO, but the documented mechanism is principally described through GSO and GRO.

Official references

Cilium Performance Tuning and BIG TCP

Study Guide topic: BIG TCP, GSO/GRO, packet-length limits, and performance.

Technical explanation

The intended answer is D, but the option contains a source-bank typographical error. The valid command is cilium sysdump , not cilium sysduwp . Read literally, none of the four displayed commands exactly answers the question.

The Cilium CLI’s sysdump operation gathers cluster-wide troubleshooting material, including Cilium configuration and endpoint state, agent and operator logs, Kubernetes workload information, routing and interface details, kernel messages, service state, policies, and selected eBPF-map output. This consolidated archive is the preferred diagnostic package when investigating Kubernetes networking or preparing a support report.

cilium status --verbose provides expanded health and deployment status, but it does not collect the comprehensive diagnostic archive requested. debuginfo is associated with the in-agent debug client—currently documented as cilium-dbg debuginfo —and produces useful local-agent API information; in Kubernetes environments it is already included as part of the system dump. cilium bugtool is not the current cluster-wide Cilium CLI command requested here.

For an exam-ready correction, option D should read cilium sysdump .

Official references

Cilium Troubleshooting and Sysdump

Study Guide topic: Cilium CLI troubleshooting, system dumps, and diagnostic collection.

Technical explanation

Hubble UI and Hubble CLI are Cilium’s integrated interfaces for examining workload network flows. Hubble records source and destination identities, namespaces, workloads, addresses, ports, forwarding verdicts, and drop reasons. When Layer 7 visibility is configured, its flow output can also contain application-level information such as HTTP methods, URLs, response codes, latency, and DNS queries. Filters can narrow the results by source workload, namespace, destination, protocol, port, or verdict, making Hubble appropriate for investigating egress behavior.

Hubble CLI provides detailed event-oriented inspection, while Hubble UI presents flows and service dependencies graphically. Hubble Relay aggregates the per-node Hubble APIs so these clients can obtain cluster-wide visibility.

Load balancing directs traffic but is not an observability interface. Kubernetes NetworkPolicy expresses permitted communications but does not by itself display application-level flow records. Fluentd and Grafana are external logging and visualization components and would violate the requirement to avoid additional tooling.

Layer 7 information requires supported traffic to be redirected through Cilium’s L7 proxy. Hubble then exposes the resulting application-layer flow events through the built-in CLI or UI, making D the complete answer.

Official references

Network Observability with Hubble ; Inspecting Network Flows .

Study Guide topic: Network Observability.

Technical explanation

Remote service affinity directs a global Service to prefer healthy backend endpoints located in remote clusters. This can support maintenance or staged rollouts in which the local copy of an application is temporarily unavailable or intentionally removed from service. Requests originating in the local cluster continue through the same global Service but are forwarded to the preferred remote backends, matching the use case described by D.

Cilium configures this behavior through the service.cilium.io/affinity: "remote" annotation. The preference affects backend selection; it does not require clients to use a different Service address. If remote backends are available, they are marked as preferred. This provides operators with a controlled way to direct traffic away from the local deployment during an update.

Option A describes local affinity from the perspective of the cluster containing the client, not remote affinity. Option B incorrectly introduces the Egress Gateway, which provides controlled source addresses and routing for outbound traffic rather than Cluster Mesh global-Service affinity. Option C describes the normal none affinity behavior, under which Cilium has no local-or-remote preference and can load-balance across both categories.

Remote affinity therefore enables temporary cross-cluster continuity while local application instances are updated or otherwise unavailable.

Official references

Cluster Mesh Service Affinity .

Study Guide topic: Cluster Mesh.

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 requirement is that traffic remain encrypted all the way from the external client to the backend Service . Therefore, TLS must not terminate at the Cilium Gateway/Envoy proxy .

With TLS Passthrough , Cilium forwards the encrypted TLS stream to the backend without decrypting the application traffic. Envoy can inspect the TLS ClientHello/SNI sufficiently to select the appropriate backend, but the TLS session itself continues to the Service. Cilium specifically supports TLS passthrough with the Gateway API TLSRoute resource .

By contrast, TLS Terminate + HTTPRoute decrypts the connection at the Gateway. Although a separate encrypted connection to the backend can be configured in some architectures, that is not the same as preserving the original end-to-end TLS session requested here. Cilium's HTTPS Gateway examples use TLS termination when the Gateway itself handles the certificate.

Study Guide topic: Service Mesh.

Technical explanation

Cilium primarily improves Kubernetes network security through identity-aware policy enforcement across Layers 3 through 7. Standard Kubernetes NetworkPolicy resources provide Layer 3 and Layer 4 controls, while CiliumNetworkPolicy extends enforcement to application-layer rules. Policies can select workloads by labels and identity, restrict protocols and destination ports, control communication with CIDRs or entities, apply DNS/FQDN rules, and authorize supported HTTP or gRPC operations. This multi-layer enforcement is the capability described by D.

API Gateway and Gateway API configurations can contribute to controlling north-south traffic, but they are not Cilium’s primary or comprehensive security mechanism. Database encryption is implemented by database, storage, or encryption-management systems rather than being a general function of Cilium. Persistent-volume backup is similarly outside Cilium’s CNI, network-policy, and observability responsibilities.

Cilium’s identity model is especially important in dynamic Kubernetes environments. Security policy follows workload identities derived from labels instead of depending exclusively on changing pod IP addresses. At Layer 7, traffic is redirected to Envoy when protocol-aware inspection or enforcement is required, while eBPF supplies the efficient kernel datapath for lower-layer processing.

Official references

Introduction to Cilium and Hubble ; Network Policy ; Layer 7 Policies .

Study Guide topic: Network Policy.

Technical explanation

Option B correctly represents the Ingress as a Gateway and an attached HTTPRoute . The Gateway is named cilium , uses gatewayClassName: cilium , and exposes an HTTP listener on port 80. The HTTPRoute uses parentRefs with the same Gateway name, cilium , so the route attaches to the declared listener. Its two rules preserve the original routing behavior: /details with PathPrefix targets the details Service on port 9080, while / with PathPrefix targets productpage on port 9080.

Option A declares a Gateway named cilium but attaches its route to nginx-gateway . Because the parent reference does not identify the displayed Gateway, it is not equivalent. Options C and D use kind: Route ; the correct resource kind for HTTP path routing is HTTPRoute . They also contain malformed or altered backend and matching fields. Option D changes the details backend name, while option C contains incorrect route structure and path content.

Cilium’s official migration example uses the same conversion pattern: the Ingress class becomes the Gateway’s class, paths move into HTTPRoute.rules , and the route identifies its Gateway through parentRefs .

The supplied key incorrectly identifies A. The verified answer is B.

Official references

HTTP Migration Example .

Study Guide topic: Service Mesh.

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.

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.