SaveMyCert
Log in
5 of 5 free questions left today·for 10 a day
KCNA · Domain 2

Container Orchestration practice questions

Container Orchestration is worth 28% of the KCNA exam — the 2nd-heaviest of the 4 domains. Networking, security, troubleshooting, and storage for orchestrated workloads. Official weighting 28%. 6 fully worked examples are further down this page, answers included.

Exam weight
28%
the 2nd-heaviest of the 4 domains
Questions
108
across 4 topics
Free, no account
5/day
a free account allows 10 a day
Explanations
Every option
right and wrong

Build a practice session

5 free questions left today.

Domains

How many?

5 free questions left today.

Mode

Ready when you are

10 fresh questions drawn across 1 of 4 domains, in Learn mode.

Review what you missed

Every question you answer incorrectly, and every question you flag while practising, is saved here automatically. Finish a session and you can come back to re-drill just those.

6 sample Container Orchestration questions, fully explained

Questions from the KCNA bank mapped to domain 2, with the answer key and the reasoning behind every option. None of them repeat the examples on the main KCNA practice page.

Question 1Container Orchestration

Which Service type is used by default when a Kubernetes Service is created without explicitly specifying a type?

Choose one.

  • a
    NodePort

    NodePort must be explicitly requested; it is not the default type.

  • b
    LoadBalancer

    LoadBalancer must be explicitly requested and typically depends on cloud provider integration; it is not the default.

  • c
    ClusterIP Correct

    ClusterIP is the default Service type, giving the Service a stable, internally reachable virtual IP.

  • d
    ExternalName

    ExternalName is a special-purpose type for CNAME mapping and must be set explicitly; it is not the default.

The concept

Kubernetes Services default to internal-only exposure unless a different type is requested.

Why that’s the answer

When the type field is omitted on a Service manifest, Kubernetes defaults to ClusterIP, which allocates an internal virtual IP reachable only from within the cluster.

How to reason it out
  1. Recall that the Service spec.type field is optional.
  2. Recall Kubernetes' default behavior for an omitted type field.
  3. Confirm ClusterIP as the internal-only default, distinct from NodePort, LoadBalancer, and ExternalName which all require explicit configuration.

Exam tip: If you do not set spec.type, a Service is a ClusterIP Service, internal to the cluster only.

Kubernetes Networking: Services, kube-proxy, CNI, DNS, and Ingress — the lesson that teaches this.

Question 2Container Orchestration

An administrator creates a NodePort Service without choosing a port number, on a cluster that uses the API server's default settings. From which range does Kubernetes allocate the node port?

Choose one.

  • a
    30000-32767 Correct

    This is the default --service-node-port-range of the API server; an unspecified nodePort is picked from it and opened on every node.

  • b
    1024-49151

    These are the IANA registered ports. Kubernetes does not hand out node ports from this range by default.

  • c
    49152-65535

    This is the IANA dynamic (ephemeral) port range, not the Kubernetes node port range.

  • d
    32768-60999

    This is the default Linux local ephemeral port range used for outbound connections, not the NodePort range.

The concept

A NodePort Service opens the same port on every node; when no port is specified, Kubernetes allocates one from the API server's service node port range, 30000-32767 by default.

Why that’s the answer

The kube-apiserver flag --service-node-port-range defaults to 30000-32767, so an unspecified nodePort lands there. The distractors are real, well-known port ranges a candidate might half-remember: IANA registered ports, IANA dynamic ports and the Linux ephemeral range.

How to reason it out
  1. Recall that node ports come from a configurable API server range.
  2. Recall its default: 30000-32767.
  3. Recognise the other ranges as IANA or Linux ephemeral ranges, not Kubernetes defaults.

Exam tip: Default NodePort range: 30000-32767, opened on every node.

Kubernetes Networking: Services, kube-proxy, CNI, DNS, and Ingress — the lesson that teaches this.

Question 3Container Orchestration

A team running on a managed cloud Kubernetes service changes its web Service from ClusterIP to LoadBalancer and leaves every other field at its default. What does Kubernetes set up so that external clients can reach the Pods?

Choose one.

  • a
    A cloud load balancer per Pod, with each Pod given its own public IP address

    Pods keep their private cluster IPs, and one load balancer serves the whole Service. A LoadBalancer Service exposes the Service, not individual Pods.

  • b
    A cloud load balancer that forwards to node ports allocated for this Service Correct

    By default a LoadBalancer Service builds on NodePort: it keeps its ClusterIP, gets a node port on every node, and the cloud controller provisions an external load balancer that sends traffic to those node ports.

  • c
    A cloud load balancer in front of the API server, which proxies requests to the Pods

    The API server is the control plane's front end, not a data path for application traffic. The cloud load balancer sends client traffic to the nodes, not through the API server.

  • d
    A cloud load balancer created for an Ingress generated from this Service

    A LoadBalancer Service creates no Ingress. Ingress is a separate layer 7 object that needs its own controller; the load balancer here belongs to the Service itself.

The concept

Service types form a ladder: ClusterIP for internal access, NodePort adds a port on every node, and LoadBalancer adds a cloud-provisioned external load balancer on top of those node ports.

Why that’s the answer

With default settings (allocateLoadBalancerNodePorts is true), a LoadBalancer Service is a NodePort Service plus an external load balancer created by the cloud provider's controller, which spreads client traffic across the nodes' allocated ports; from there kube-proxy's rules deliver it to ready Pods. A load balancer per Pod, a path through the API server, or a generated Ingress are all mechanisms the Service type does not use.

How to reason it out
  1. Recall that LoadBalancer builds on NodePort, which builds on ClusterIP.
  2. Identify who provides the external address: the cloud provider's load balancer.
  3. Follow the path: load balancer to node port to kube-proxy rules to a ready Pod.
  4. Reject options that expose Pods individually, route through the API server or create an Ingress.

Exam tip: LoadBalancer = ClusterIP + NodePort + a cloud load balancer in front of the node ports.

Kubernetes Networking: Services, kube-proxy, CNI, DNS, and Ingress — the lesson that teaches this.

Question 4Container Orchestration

A Service manifest sets spec.clusterIP to None, and its selector matches three ready Pods. What does a DNS A-record lookup of the Service's name return to a client Pod?

Choose one.

  • a
    One virtual IP that kube-proxy load-balances across the three ready Pods

    That is a normal ClusterIP Service. Setting clusterIP to None means no virtual IP is allocated, so there is nothing for kube-proxy to load-balance.

  • b
    A CNAME record that points at an external hostname set on the Service

    A CNAME answer comes from an ExternalName Service, which has no selector. This Service selects Pods.

  • c
    No record, since Service DNS entries are built from a Service's cluster IP

    A Service without a cluster IP is still published in DNS; CoreDNS answers with the selected Pods' addresses instead of a virtual IP.

  • d
    One A record per ready Pod, each holding that Pod's own IP address Correct

    clusterIP: None makes the Service headless. DNS returns the IPs of the individual ready Pods, letting clients choose or address specific Pods.

The concept

A headless Service (clusterIP: None) gets no virtual IP and no kube-proxy load balancing; DNS returns the selected Pods' own IPs instead.

Why that’s the answer

Headless Services exist for clients that need to reach specific Pods rather than any replica, most notably StatefulSets, where each Pod also gets its own stable DNS name. The tempting answers describe the other Service shapes: a single virtual IP is a ClusterIP Service, a CNAME is an ExternalName Service, and the Service does not disappear from DNS just because it has no cluster IP.

How to reason it out
  1. Recognise clusterIP: None as the headless setting.
  2. Recall that headless means no virtual IP and no proxying.
  3. Recall that DNS then answers with the ready Pod IPs.
  4. Match the answer: one A record per ready Pod.

Exam tip: Headless Service: no cluster IP, and DNS hands back the Pod IPs themselves.

Kubernetes Networking: Services, kube-proxy, CNI, DNS, and Ingress — the lesson that teaches this.

Question 5Container Orchestration

Applications in a cluster connect to a managed database at db.example.net. The team wants them to use the in-cluster name orders-db instead, so the database host can change later without redeploying the applications. Which Service provides this?

Choose one.

  • a
    A ClusterIP Service whose label selector matches the database's Pods

    The database is outside the cluster, so there are no Pods for a selector to match; the Service would have no endpoints.

  • b
    A NodePort Service that publishes db.example.net on a port of each node

    NodePort exposes in-cluster Pods outward on node ports. It does not alias an outside hostname for in-cluster clients.

  • c
    A LoadBalancer Service whose external IP is set to the database address

    A LoadBalancer Service brings outside traffic into the cluster; setting its external address does not make orders-db resolve to the database.

  • d
    An ExternalName Service whose externalName field is db.example.net Correct

    An ExternalName Service makes cluster DNS answer orders-db with a CNAME to db.example.net. Changing the hostname later means editing one Service, not the applications.

The concept

An ExternalName Service maps an in-cluster Service name to an external DNS name by returning a CNAME record; no selector, endpoints or proxying are involved.

Why that’s the answer

The requirement is a stable in-cluster name for something outside the cluster. ExternalName does exactly that at the DNS layer: CoreDNS answers orders-db.<namespace>.svc.cluster.local with a CNAME to db.example.net, so the target can be repointed by editing the Service. ClusterIP needs Pods to select, while NodePort and LoadBalancer expose cluster workloads outward rather than aliasing an outside host.

How to reason it out
  1. Note the target lives outside the cluster and is identified by hostname.
  2. Ask which Service type works purely in DNS, without selecting Pods.
  3. Recall that ExternalName returns a CNAME to the configured hostname.
  4. Reject types that expose in-cluster Pods instead.

Exam tip: ExternalName = an in-cluster alias (CNAME) for an outside hostname.

Kubernetes Networking: Services, kube-proxy, CNI, DNS, and Ingress — the lesson that teaches this.

Question 6Container Orchestration

Which Kubernetes object tracks the current set of Pod IP addresses and readiness status backing a Service?

Choose one.

  • a
    ConfigMap

    ConfigMaps store non-sensitive configuration data; they have no role in tracking Service backends.

  • b
    EndpointSlice Correct

    EndpointSlices track the network endpoints (Pod IPs plus readiness) that back a Service, and are updated automatically as Pods come and go.

  • c
    NetworkPolicy

    NetworkPolicy defines allowed traffic rules for Pods; it does not track which Pods back a Service.

  • d
    Ingress

    Ingress defines HTTP routing rules to Services; it does not itself track Pod-level Service backends.

The concept

EndpointSlices are the mechanism Kubernetes uses to record which Pods currently back a given Service.

Why that’s the answer

As Pods matching a Service's label selector are created, become ready, or are removed, the EndpointSlice controller keeps the corresponding EndpointSlice objects updated with the current, ready Pod IPs.

How to reason it out
  1. Recall that a Service selects Pods by label, but needs somewhere to record the resulting IPs.
  2. Recall that EndpointSlices (the successor to the older Endpoints object) hold that list, split into slices for scalability.
  3. Rule out ConfigMap, NetworkPolicy, and Ingress, none of which track Pod backend membership.

Exam tip: EndpointSlices are the live record of which Pod IPs currently back a Service.

Kubernetes Networking: Services, kube-proxy, CNI, DNS, and Ingress — the lesson that teaches this.

What KCNA domain 2 tests, topic by topic

The official exam guide breaks Container Orchestration into 4 topics. The question bank follows the same split, so a weak topic shows up as a cluster of misses you can go back and read.

Published KCNA practice questions per topic in Container Orchestration
TopicWhat it coversQuestions
NetworkingOfficial KCNA competency (Container Orchestration). The Kubernetes networking model: Pod-to-Pod networking, Services and kube-proxy, cluster DNS, the Container Network Interface (CNI), Ingress, and network policies.27
SecurityOfficial KCNA competency. Cloud-native and Kubernetes security basics: the 4Cs of cloud-native security, RBAC and service accounts, Secrets, and the container, network, and policy security surface.27
TroubleshootingOfficial KCNA competency. Diagnosing workloads and clusters: reading Pod status and events, kubectl logs / describe / exec, and identifying common failure modes across Pods, Services, and nodes.27
StorageOfficial KCNA competency. Kubernetes storage: Volumes, PersistentVolumes and PersistentVolumeClaims, StorageClasses and dynamic provisioning, and the Container Storage Interface (CSI).27
Total108

Revise Container Orchestration before you drill it

Other KCNA domains

Container Orchestration: your questions

Container Orchestration is domain 2 of the KCNA exam guide and carries 28% of the scored content — the 2nd-heaviest of the 4 domains. On a 60-question paper that works out to roughly 17 questions, though CNCF does not publish an exact per-domain count and individual exam forms vary.

Source

The domain weight and topic list on this page come from the official KCNA exam guide.