SaveMyCert
Log in
5 of 5 free questions left today·for 10 a day
KCSA · Domain 1

Overview of Cloud Native Security practice questions

Overview of Cloud Native Security is worth 14% of the KCSA exam — the 5th-heaviest of the 6 domains. The layered model of cloud-native security, the provider and infrastructure layer, security controls and frameworks, isolation techniques, image and artifact security, and workload and application code security. Official weighting 14%. 6 fully worked examples are further down this page, answers included.

Exam weight
14%
the 5th-heaviest of the 6 domains
Questions
50
across 2 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 6 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 Overview of Cloud Native Security questions, fully explained

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

Question 1Overview of Cloud Native Security

A platform team writes RBAC roles that limit each developer group to its own namespaces and adds NetworkPolicies between namespaces. In the 4Cs model, which layer are they securing?

Choose one.

  • a
    The Cluster layer Correct

    RBAC and NetworkPolicy are Kubernetes API objects that configure the cluster itself, which is the Cluster layer.

  • b
    The Cloud layer

    Cloud-layer controls are set in the provider or data-centre infrastructure, such as account permissions and network ACLs, not Kubernetes objects.

  • c
    The Container layer

    Container-layer controls concern images and how individual containers run, such as non-root users and image scanning.

  • d
    The Code layer

    Code-layer controls live in the application code and its dependencies, not in Kubernetes authorization or traffic rules.

The concept

The Cluster layer covers the Kubernetes components and the cluster's own configuration: authorization, admission, network policy, Secrets and so on.

Why that’s the answer

RBAC roles and NetworkPolicies are configured through the Kubernetes API and govern who may act in the cluster and which Pods may talk to each other. That makes them Cluster-layer controls. Network ACLs in the provider would be Cloud; image and runtime settings would be Container; the application's input validation or dependency hygiene would be Code.

How to reason it out
  1. Identify the objects: Role/RoleBinding and NetworkPolicy.
  2. Both are Kubernetes resources that configure the cluster.
  3. Map Kubernetes-native configuration to the Cluster layer.

Exam tip: Kubernetes objects such as RBAC and NetworkPolicy secure the Cluster layer.

KCSA: The 4Cs of Cloud Native Security, Infrastructure Security and Security Controls — the lesson that teaches this.

Question 2Overview of Cloud Native Security

After a container escape, an attacker holds root on a worker node and can use the credentials issued to the node's virtual machine. Which layer's controls decide how much damage those credentials can do?

Choose one.

  • a
    The Cluster layer, through the RBAC rules bound to the node

    RBAC limits what the node's Kubernetes identity can do in the API. It has no effect on calls the attacker makes to the provider's API with the virtual machine's credentials.

  • b
    The Container layer, through the escaped container's settings

    Container settings could have helped prevent the escape, but once the attacker is on the node they no longer limit the credentials the virtual machine holds.

  • c
    The Cloud layer, through the permissions granted to the node Correct

    The virtual machine's identity is defined and scoped in the provider. Least-privilege permissions on that identity, a Cloud-layer control, cap what a stolen credential can reach.

  • d
    The Code layer, through the escaped workload's dependency policy

    Dependency hygiene in the workload might have prevented the initial compromise; it cannot restrict a credential the attacker already holds.

The concept

Each 4C layer owns different controls; cloud credentials of the infrastructure are governed in the Cloud layer.

Why that’s the answer

The question is not how the attacker got in but what limits the credential now in their hands. The credentials issued to a node's virtual machine (an instance role, managed identity or service account) belong to an identity defined in the provider, and the Kubernetes guidance says the provider permissions given to nodes and the control plane should follow least privilege. RBAC is the tempting answer, but it only governs the node's Kubernetes API identity, not calls to the provider's API. Container and Code controls act earlier in the attack, before the escape.

How to reason it out
  1. Separate the two identities a node has: a Kubernetes identity and a cloud identity.
  2. The stolen credential belongs to the virtual machine's provider identity, which is scoped in the provider.
  3. Provider-side permissions are a Cloud-layer control.

Exam tip: A node's virtual machine credentials are limited by Cloud-layer least privilege, not by Kubernetes RBAC.

KCSA: The 4Cs of Cloud Native Security, Infrastructure Security and Security Controls — the lesson that teaches this.

Question 3Overview of Cloud Native Security

According to the 4Cs model of cloud native security, why can strong security in an application's code not make up for weak security in the cloud infrastructure underneath it?

Choose one.

  • a
    Each layer is scanned by its own tool, so code findings do not appear in the cloud reports

    Tooling and reporting are not the reason; the model is about how layers depend on each other, not which scanner reports on them.

  • b
    Each layer is owned by one team, so code fixes are not approved for the cloud infrastructure

    Ownership varies by organisation and is not the principle; the point is that inner layers rely on the outer layers' security.

  • c
    Each layer builds on the layer around it, so a breach of an outer layer exposes the inner ones Correct

    The model treats Cloud, Cluster, Container and Code as nested layers; the inner layers depend on the outer ones, so a weak base undermines everything built on it.

  • d
    Each layer uses its own credentials, so code-level secrets expire before the cloud ones

    Credential lifetimes have nothing to do with the model's layering; this describes no part of the 4Cs.

The concept

In the 4Cs model the layers are nested: Code runs in Containers, which run in a Cluster, which runs on the Cloud.

Why that’s the answer

Kubernetes' description of the 4Cs states that each layer builds on the next outermost layer, and that you cannot safeguard against poor security in the base layers by addressing security at the Code level. If an attacker controls the cloud account or the cluster, the application's careful code no longer matters: they can read its data, change its configuration or replace it.

How to reason it out
  1. Picture the layers as nested rings: Cloud, Cluster, Container, Code.
  2. An attacker in an outer ring controls everything inside it.
  3. So the inner layers inherit the weakness of the outer ones.

Exam tip: Code security sits on top of the others; it cannot fix a weak Cloud or Cluster layer.

KCSA: The 4Cs of Cloud Native Security, Infrastructure Security and Security Controls — the lesson that teaches this.

Question 4Overview of Cloud Native Security

A team's application validates every input, uses TLS everywhere and passes static analysis. A review finds that the cluster's etcd endpoint is reachable from the internet without client certificates. Which statement best describes the team's position?

Choose one.

  • a
    The application is at risk because the outer layers it relies on are weak Correct

    etcd holds the whole cluster state. An open etcd is a Cluster/Cloud-layer failure that bypasses the application's code controls entirely.

  • b
    The application is safe, because etcd stores cluster objects rather than application data

    etcd holds the application's Secrets, ConfigMaps and Deployments. Whoever reaches it can read those Secrets and change the objects that define how the application runs.

  • c
    The application's Secrets are exposed, but its other objects are of little use to an attacker

    Write access matters as much as read access: an attacker can change the application's Deployment, for example its image or command, without ever touching its code.

  • d
    The application is safe as long as the disk that holds etcd's data is encrypted at rest

    Encryption at rest protects copied disks and backups. A live etcd endpoint serves decrypted data to anyone who connects, so disk encryption does not close this exposure.

The concept

In the 4Cs model inner-layer controls (Code) depend on the outer layers (Cluster, Cloud) being sound.

Why that’s the answer

An etcd endpoint open to the internet lets anyone read Secrets and rewrite any object in the cluster, including this application's Deployments. None of that passes through the application's code, so its input validation and TLS give no protection. The tempting answers each underrate the exposure: etcd does hold application data, write access is as dangerous as reading Secrets, and disk encryption at rest does nothing against a live endpoint that serves the data. This is exactly the 4Cs point: weak base layers cannot be compensated for in the Code layer.

How to reason it out
  1. Locate the weakness: etcd, the cluster datastore, exposed on the network.
  2. Ask whether the attack path goes through the application's code; it does not.
  3. Conclude that the inner-layer controls are bypassed.

Exam tip: A weak outer layer bypasses inner-layer controls; good code cannot protect an exposed etcd.

KCSA: The 4Cs of Cloud Native Security, Infrastructure Security and Security Controls — the lesson that teaches this.

Question 5Overview of Cloud Native Security

A company runs its workloads on a managed Kubernetes service in which the provider operates the control plane. Which task normally remains the company's responsibility?

Choose one.

  • a
    Writing RBAC rules that limit what its users and workloads can do Correct

    Who may do what in the cluster is configuration the customer owns. The provider runs the API server, but the customer decides the RBAC rules enforced in it.

  • b
    Patching the kube-apiserver binaries on the control plane hosts

    In a managed service the provider runs and patches the control plane components; the customer cannot reach those hosts.

  • c
    Replacing failed etcd members and keeping the datastore healthy

    Operating etcd, including its availability and member health, is part of the managed control plane the provider runs.

  • d
    Scaling the control plane hosts when the API request load grows

    Control plane capacity is the provider's job in a managed service; customers do not size those hosts.

The concept

Shared responsibility: the provider secures what it operates (the managed control plane), the customer secures what it configures and deploys.

Why that’s the answer

When the provider operates the control plane, the components on it (API server, etcd, controller manager, scheduler) are patched, scaled and kept available by the provider. What the customer puts into the cluster stays with the customer: RBAC, workload configuration, network policies, Secrets handling and their own images. The three distractors are all real control-plane operations, which is why they are tempting, but they belong to the provider in this model.

How to reason it out
  1. Ask who operates the component: in a managed service the provider runs the control plane.
  2. Ask who configures the setting: RBAC is the customer's configuration.
  3. Assign each task to the party that operates or configures it.

Exam tip: Provider runs the managed control plane; the customer owns RBAC, workloads and their configuration.

KCSA: The 4Cs of Cloud Native Security, Infrastructure Security and Security Controls — the lesson that teaches this.

Question 6Overview of Cloud Native Security

A team installs Kubernetes itself on virtual machines it rents from a cloud provider; the control plane runs on those VMs. An auditor asks who must make sure Secrets in etcd are encrypted at rest. What is the correct answer?

Choose one.

  • a
    The provider, because it owns the physical disks of the VMs

    Physical disk encryption by the provider does not configure Kubernetes encryption at rest; on a self-managed cluster the API server's encryption configuration is the team's to set.

  • b
    The team, because it operates and configures the control plane Correct

    On self-managed Kubernetes the customer operates the control plane, so configuring Secret encryption at rest (an EncryptionConfiguration on the API server) is their job.

  • c
    The provider, because etcd is part of the Kubernetes control plane

    That holds for a managed service where the provider runs the control plane. Here the team installed and runs it, so the provider has no access to its configuration.

  • d
    The team, but not until the provider has enabled the feature for it

    The feature is built into Kubernetes; nothing needs to be enabled by the provider before the team configures it.

The concept

Where the line falls in shared responsibility depends on who operates each layer, which differs between self-managed and managed Kubernetes.

Why that’s the answer

Responsibility follows operation. The provider runs the VMs and the infrastructure under them, but the team installed Kubernetes, so the control plane, including etcd and the API server's encryption-at-rest configuration, is theirs. The near-twin is the managed-service answer: there the provider runs etcd. Provider disk encryption is useful defence in depth but is not Kubernetes encryption of Secret data, which is configured on the API server.

How to reason it out
  1. Identify who operates the control plane: the team, on its own VMs.
  2. Encryption of Secrets at rest is set in the API server's configuration.
  3. So it belongs to whoever runs the API server.

Exam tip: Self-managed control plane = the customer configures etcd and Secret encryption.

KCSA: The 4Cs of Cloud Native Security, Infrastructure Security and Security Controls — the lesson that teaches this.

What KCSA domain 1 tests, topic by topic

The official exam guide breaks Overview of Cloud Native Security into 2 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 KCSA practice questions per topic in Overview of Cloud Native Security
TopicWhat it coversQuestions
The 4Cs, cloud provider and infrastructure security, and controls and frameworksOfficial KCSA competencies (Overview of Cloud Native Security): The 4Cs of Cloud Native Security; Cloud Provider and Infrastructure Security; Controls and Frameworks. Scope: the Cloud, Cluster, Container and Code layers and how each depends on the one beneath it, the shared responsibility model, securing the hosts and cloud accounts a cluster runs on, and preventive, detective and corrective controls.25
Isolation techniques, artifact and image security, and workload code securityOfficial KCSA competencies (Overview of Cloud Native Security): Isolation Techniques; Artifact Repository and Image Security; Workload and Application Code Security. Scope: namespaces, nodes, sandboxed runtimes and virtual machines as isolation boundaries, minimal and scanned images, signing and trusted registries, and secure application code and dependencies.25
Total50

Revise Overview of Cloud Native Security before you drill it

Other KCSA domains

Overview of Cloud Native Security: your questions

Overview of Cloud Native Security is domain 1 of the KCSA exam guide and carries 14% of the scored content — the 5th-heaviest of the 6 domains. On a 60-question paper that works out to roughly 8 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 KCSA exam guide.