SaveMyCert
Log in
5 of 5 free questions left today·for 10 a day
KCSA last-day review

KCSA cheat sheet — every exam topic on one page

128 key facts across 6 exam domains — every topic on the KCSA blueprint, with the exam pattern behind each. A condensed cheat sheet, distilled from the full KCSA revision notes. Skim it the week of your exam.

Updated

Overview of Cloud Native Security

14% of the exam

KCSA: The 4Cs of Cloud Native Security, Infrastructure Security and Security Controls

  • The 4Cs are Cloud, Cluster, Container and Code; place a control by where it is configured, not by what it protects.
  • Each layer builds on the one around it, so strong application code cannot make up for a weak cloud account or cluster.
  • Responsibility follows operation: on a managed service the provider runs the control plane, but RBAC, workloads and self-managed nodes stay with the customer; a self-installed cluster puts the whole control plane on the customer.
  • Keep the API endpoint off the internet and limit it to administrative sources; this is an extra layer beside authentication and RBAC, not a replacement.
  • Nodes should accept only control-plane traffic on the needed ports (kubelet 10250) plus NodePort and LoadBalancer Service traffic.
  • Give the control plane and nodes only the cloud permissions their own components use, block Pod access to the metadata endpoint, and use workload identity instead of node credentials or stored keys.
  • Only the API server should connect to etcd, over mutual TLS, and etcd's storage should be encrypted because it holds every Secret.
  • Preventive controls stop a bad state, detective controls notice it and corrective controls restore a good state; defence in depth needs independent controls in several layers.
  • The CIS Kubernetes Benchmark is the per-setting hardening baseline that kube-bench checks; the CNCF lifecycle phases are Develop, Distribute, Deploy and Runtime.
How the exam tests this

Questions on this topic are short scenarios at a foundational level. Some describe a control and ask which 4C layer, control type (preventive, detective or corrective) or lifecycle phase it belongs to. Others describe a risk or a symptom in the infrastructure around a cluster, such as exposed endpoints, node credentials or connectivity between the control plane and nodes, and ask for the control or explanation that fits. Shared-responsibility items ask who secures a component under a given deployment model (managed control plane, managed or self-managed nodes, a self-installed cluster). Harder items combine two facts or add a constraint, such as which component's identity should hold a cloud permission, or which design gives one Pod cloud access while meeting every stated requirement.

KCSA Isolation, Image Security and Application Code Security

  • Standard containers share the host kernel, so a kernel vulnerability is a risk shared by every workload on the node.
  • Namespaces control what a process sees, cgroups control how much it uses; neither gives a container its own kernel.
  • A Kubernetes namespace scopes names, RBAC, quotas and policies, but Pods in different namespaces can talk by default and cluster-scoped objects (Nodes, PersistentVolumes, ClusterRoles) sit outside it.
  • Taints keep other Pods off a dedicated pool; node affinity or a nodeSelector keeps the sensitive Pods on it. You need both.
  • gVisor intercepts system calls in a user-space kernel, Kata Containers runs each Pod in a lightweight VM; select either per Pod with runtimeClassName and apply them selectively because of overhead and compatibility.
  • Isolation strength runs from namespace to dedicated nodes to sandboxed runtime to separate clusters on separate VMs; the scenario's cost or trust constraint decides.
  • Distroless or scratch bases and multi-stage builds shrink what an image contains; signing and registry controls protect provenance and integrity, not contents.
  • Scan in CI and rescan on a schedule, and reference production images by digest so the reviewed build is what runs.
  • A signature proves publisher and integrity, not the absence of vulnerabilities; mirror approved images into a private registry to control their source.
  • Secrets in a layer, ENV or build argument stay recoverable; use BuildKit secret mounts at build time and Kubernetes Secrets at run time, and set a non-root USER in the image.
How the exam tests this

KCSA questions on this topic are short scenarios and definitions. Expect to explain the shared-kernel limit of standard containers, to contrast containers with virtual machines, and to match a Linux feature (namespaces, cgroups, seccomp, capabilities) to what it isolates. Namespace questions check what a namespace does not isolate: network traffic by default and cluster-scoped objects such as PersistentVolumes, which a namespaced Role cannot grant. Isolation-design scenarios state a constraint, such as sharing nodes to cut cost, accepting cost for the strongest isolation or not relying on per-Pod settings, and ask for the boundary that meets it; know dedicated nodes, the one-way behaviour of taints and tolerations, gVisor versus Kata, RuntimeClass and the overhead trade-off of sandboxes. Image questions separate controls that look alike: minimal bases and multi-stage builds change what the image contains, scanning finds known CVEs and must be repeated, digests pin content while tags move, signatures prove publisher and integrity rather than safety, and private mirrors control the image source. Code questions cover secrets left in layers or build arguments, BuildKit secret mounts, Kubernetes Secrets versus ConfigMaps, SCA and lockfiles for dependencies, SAST for first-party code and a non-root USER in the Dockerfile. Some items are Select TWO.

Kubernetes Cluster Component Security

22% of the exam

KCSA Control Plane Security: API Server, Controller Manager, Scheduler and etcd

  • The API server checks every request in the order authentication, authorization, admission; only admission sees the object's content.
  • Requests without credentials become system:anonymous in system:unauthenticated, never system:authenticated, and get only what is bound to them.
  • AlwaysAllow makes every valid credential a cluster administrator; production runs Node,RBAC, and dropping Node breaks kubelets.
  • NodeRestriction limits a kubelet to its own Node and Pods, and labels under node-restriction.kubernetes.io/ cannot be set by kubelets.
  • Use mutual TLS to etcd, and set --kubelet-certificate-authority only after kubelets have CA-signed serving certificates.
  • The service account signing key mints tokens and the cluster CA key mints superuser certificates; lock both down and rotate the signing key with an overlap.
  • Give the controller manager per-controller service accounts, and bind it and the scheduler to 127.0.0.1 with profiling off.
  • A compromised scheduler decides where Pods run; it reaches cluster state only through the API server.
  • Write access to etcd is root on the cluster: allow its client port only from the API server, and give other tools API access instead.
  • Encrypt Secrets at rest (KMS v2 preferred), rewrite existing Secrets after enabling it, and keep backups encrypted and away from their keys.
How the exam tests this

KCSA questions on this topic are mostly short definitions and scenarios about which component, flag or setting does what. Expect to order the API server's request stages and work out which stage rejected a request, to name the identity and group of an anonymous caller and trace an exposure back to a binding, and to explain the risks of AlwaysAllow and of removing the Node authorizer. NodeRestriction questions separate it from authorization and from other admission plugins, and test which label prefixes a kubelet may set. TLS questions cover mutual TLS to etcd and the kubelet serving-certificate verification flag, including why it needs CA-signed kubelet certificates first. Key questions distinguish the service account signing key, its public verification keys, the cluster CA key and encryption keys, and the safe order of a signing-key rotation. Controller manager and scheduler items cover per-controller credentials, bind address, profiling and what a stolen scheduler credential allows. etcd items cover why direct access equals cluster root, which hosts may reach its client port, how other tools should read state, how the EncryptionConfiguration provider order works, why existing Secrets must be rewritten, and how backups and their keys are protected. One item may ask you to select two answers.

KCSA Node Security: Kubelet, Container Runtime, kube-proxy and Pods

  • Turn kubelet anonymous authentication off; when it is on, credential-less requests become system:anonymous in system:unauthenticated and only RBAC bindings decide what they get.
  • Run kubelets with Webhook authorization: AlwaysAllow lets any valid token, even a stolen low-privilege one, run commands in every container on the node.
  • Kubelet paths map to nodes subresources; get on nodes/proxy can execute commands, so monitoring needs only nodes/metrics and nodes/stats.
  • The read-only port serves Pod details over HTTP with no checks and is not covered by anonymous-auth; set readOnlyPort: 0.
  • The kubelet calls containerd or CRI-O over CRI, which calls runc; the runtime socket is root on the node, and runtime CVEs are fixed by patching every node.
  • kube-proxy runs as a privileged host-network DaemonSet that programs Service forwarding; keep metrics on 127.0.0.1 and use nodePortAddresses to keep NodePorts off public interfaces.
  • runAsNonRoot is a check enforced by the kubelet at start; pair it with a non-zero runAsUser. allowPrivilegeEscalation: false is inconsistent with privileged (rejected by the API server) and with SYS_ADMIN, so remove those to keep no_new_privs.
  • Drop ALL capabilities and add back only what is needed; set seccomp RuntimeDefault, because unset means Unconfined.
  • readOnlyRootFilesystem stops even root from writing to the image; give writable paths an emptyDir.
  • Disable token automount for Pods that never call the API (the Pod setting overrides the ServiceAccount), avoid host namespaces, and use hostUsers: false for root-in-container images.
How the exam tests this

KCSA questions on this topic are mostly short definitions and scenarios about which component or setting does what. Kubelet items separate anonymous authentication from Webhook authorization, ask which KubeletConfiguration setting or flag closes a gap, and test how kubelet paths map to nodes subresources, including why get on nodes/proxy is not read-only. Read-only port items ask what it exposes. Runtime items cover the CRI and its sibling interfaces, the risk of a mounted runtime socket, and how runtime vulnerabilities are remediated. kube-proxy items cover what it maintains, how it is deployed, and its metrics, health check and NodePort address settings. Pod items work through securityContext fields (users and groups, privilege escalation, capabilities, seccomp profile types, readOnlyRootFilesystem), service account token automount and token lifetime, host namespaces and user namespaces. Scenarios usually add a constraint, such as least privilege or minimal disruption, that decides between workable options.

KCSA Container Networking, Client Security and Storage Security

  • The Pod network is flat: any Pod can reach any Pod across nodes and namespaces until a NetworkPolicy, enforced by the CNI plugin, restricts it.
  • ClusterIP keeps a Service off external networks but is reachable from every Pod; the selector chooses backends, not allowed clients.
  • The container runtime runs the CNI plugin from /opt/cni/bin with config from /etc/cni/net.d as root, so write access to those paths is root on the node.
  • Kubernetes does not encrypt Pod-to-Pod traffic; use CNI node encryption, mesh mutual TLS or application TLS. Node encryption proves the sending node, not the workload.
  • Block Pods from 169.254.169.254 with an egress NetworkPolicy ipBlock except entry; the metadata API can hand out the node's cloud credentials.
  • A kubeconfig is a portable identity; never use insecure-skip-tls-verify, supply certificate-authority-data, and inspect untrusted files for exec plugins.
  • Client certificates cannot be revoked and there are no User objects; remove the bindings for the certificate's user name and groups, and prefer short-lived OIDC tokens with individual least-privilege identities.
  • super-admin.conf is in system:masters and bypasses RBAC, so keep it offline; admin.conf's access comes from a removable ClusterRoleBinding.
  • Baseline blocks hostPath in a Pod, but the right to create PersistentVolumes can reopen it through a hostPath PV and a claim.
  • Retain leaves data on Released volumes; ReadWriteOncePod limits a volume to one Pod; volume encryption comes from the StorageClass and CSI driver, not EncryptionConfiguration.
How the exam tests this

KCSA questions on this topic are mostly short scenarios about default behaviour and which control fits. Networking items test the flat Pod network (whether a cross-namespace or cross-node connection succeeds, what ClusterIP and selectors really restrict), which component assigns Pod IPs, why the CNI directories are sensitive, and how to encrypt Pod traffic under constraints such as no code changes or no sidecars, including the gap between node encryption and workload identity. Expect a question on why and how to block Pods from the cloud metadata API, with near-miss controls in the wrong direction or layer. Client items cover what a kubeconfig holds, insecure-skip-tls-verify and the unknown-authority error, reviewing an untrusted kubeconfig, limiting damage from a stolen file, what remains after a client certificate leaks or an OIDC account is disabled, admin.conf versus super-admin.conf, and exposed kubectl proxy listeners. Storage items cover hostPath and Pod Security Standards, scoping a necessary hostPath, PV creation rights, reclaim policies, access modes and where volume encryption is configured. One item may ask you to select two answers.

Kubernetes Security Fundamentals

22% of the exam

KCSA Pod Security Standards and Pod Security Admission

  • Privileged has no restrictions (trusted infrastructure), Baseline blocks known privilege escalations but admits default Pods, and Restricted applies current hardening for security-critical workloads.
  • Baseline forbids host namespaces, privileged containers, adding capabilities outside the default set (such as NET_ADMIN), hostPath volumes and an Unconfined seccomp profile; it allows root.
  • Restricted adds allowPrivilegeEscalation: false, runAsNonRoot, runAsUser not 0, an explicit RuntimeDefault or Localhost seccomp profile, drop ALL (add back only NET_BIND_SERVICE) and a short list of volume types.
  • A securityContext configures the runtime; a profile is a control-plane rule about which values are accepted. Pod Security Admission never mutates a Pod.
  • enforce rejects, audit annotates the audit log, warn returns a client warning; each mode is evaluated independently at its own level.
  • Levels are pod-security.kubernetes.io/<MODE>: <LEVEL> labels on the Namespace only; -version labels pin a release's definition or track latest.
  • Unlabelled namespaces fall back to AdmissionConfiguration defaults, which are privileged unless set; a namespace label overrides the default for that mode.
  • enforce checks only Pods, so a violating Deployment is created and its ReplicaSet records FailedCreate events; audit and warn also check Pod templates.
  • Exemptions (usernames, runtimeClasses, namespaces) live in the API server's AdmissionConfiguration; never exempt controller service accounts.
  • Roll out with kubectl label --dry-run=server, then an audit soak (dry runs miss CronJobs and scaled-to-zero workloads), then enforce; PSP was removed in v1.25 and PSA is its non-mutating replacement.
How the exam tests this

KCSA questions on this topic are short definitions and scenarios. Expect to match profiles to audiences, decide whether a particular Pod setting violates Baseline or only Restricted, and spot the missing fields in a rejected manifest, including whether a Pod-level setting already covers the containers. Mode questions combine labels and ask what the developer sees, what is recorded and whether the Pod or workload is created. Others test label syntax and version pins, how cluster defaults and namespace labels interact, which exemption fits a requirement, how to check a level before enforcing it, and what changed when PodSecurityPolicy was removed. Distractors are usually real controls that belong to a different profile, mode or mechanism.

KCSA Authentication, Secrets and Audit Logging

  • Kubernetes has no User objects: people are identified by client certificates, tokens or an OIDC provider, while service accounts are API objects.
  • 401 means the credential was not accepted; 403 means the identity was accepted but not authorized. Every authenticated identity is in system:authenticated.
  • A client certificate's CN is the user name and each O value is a group; system:masters bypasses RBAC and a certificate cannot be revoked, only expire.
  • Service accounts authenticate as system:serviceaccount:<ns>:<name> and are in system:serviceaccounts and system:serviceaccounts:<ns>.
  • Prefer TokenRequest tokens (kubectl create token, projected volumes): time-limited, audience-bound and tied to the Pod. Static token files and legacy token Secrets never expire.
  • The API server validates OIDC ID tokens itself, so a disabled user's existing token works until it expires, and claim prefixes such as oidc: change the group names RBAC sees.
  • Secret values are base64-encoded, not encrypted; list, watch and the right to create Pods all expose them. Scope access with a namespaced Role and resourceNames.
  • Secret volumes update in running Pods; subPath mounts and environment variables do not.
  • In an EncryptionConfiguration the first provider writes and identity means plain text; rotate keys by adding the new key second everywhere, then first everywhere.
  • Audit logging needs a policy file; the first matching rule sets the level, so log Secrets at Metadata early, and only blocking-strict fails a request whose RequestReceived event cannot be recorded.
How the exam tests this

KCSA questions on this topic are short definitions and practical scenarios. Expect to name the user or group a certificate, service account or OIDC token produces, read a 401 or 403 correctly, and judge what a binding to a built-in group really covers, including system:masters. Token questions compare lifetimes, audiences and how each kind of token is revoked. Secret questions cover base64 versus encryption, Secret types and their required keys, the indirect ways to read a Secret, the narrowest grant for one Secret, and which consumption method picks up a rotated value. Others give an EncryptionConfiguration or a key rotation plan and ask what gets written, or give an audit policy and ask what a request logs, which level, stage or omitStages change fits a requirement, and which backend mode fits a strict recording rule. Distractors are usually real settings that belong to a different stage, level, field or mechanism.

KCSA Isolation, Segmentation and Kubernetes Network Policy

  • A namespace scopes names; RBAC, ResourceQuota, LimitRange and NetworkPolicy provide the actual tenant isolation
  • ResourceQuota caps a namespace's totals at admission and never evicts running Pods; LimitRange sets per-container defaults and bounds
  • A CPU or memory quota makes requests or limits mandatory, and its rejections hit the ReplicaSet's Pods, not the Deployment
  • Pods are non-isolated until a policy selects them for a direction; ingress and egress isolation are independent
  • Policies are additive allow lists with no deny, no priority and no order; both the source's egress and the destination's ingress must allow a connection, and replies are implicit
  • Omitted policyTypes means Ingress always, plus Egress only if egress rules exist
  • podSelector: {} with a policyType and no rules is default deny for that namespace only; there is no cluster-wide default in the API
  • Peers in one from/to item are ANDed, separate items are ORed; a podSelector alone looks only in the policy's namespace; select namespaces with kubernetes.io/metadata.name
  • ipBlock is for cluster-external ranges; default-deny egress needs a DNS allow to kube-system on port 53 UDP and TCP
  • Only the network plugin enforces NetworkPolicy, including endPort; the API cannot log, do TLS, target Services by name or block node traffic
How the exam tests this

KCSA questions on this topic are short definitions and scenarios. Expect to predict which traffic a set of policies allows or blocks, often with a YAML snippet, and to spot why a policy does not behave as intended: the wrong direction, defaults filled in for a missing policyTypes, AND versus OR peers, a podSelector looking in the wrong namespace, a missing DNS allow, or a plugin that does not enforce the policy. Others ask which spec gives default deny or allow all, how to select a namespace or external range, what the API cannot do, and how a tenant namespace is contained with ResourceQuota and LimitRange, including what quota admission does to Pods that already run or omit their requests. Distractors are usually real Kubernetes objects or fields that belong to another direction, scope or component.

Kubernetes Threat Model

16% of the exam

KCSA Kubernetes Trust Boundaries, Persistence and Denial of Service

  • A trust boundary is where data or requests pass to a more privileged component; namespaces, RBAC and NetworkPolicies are controls that defend boundaries, not boundaries themselves.
  • The API server is the only client of etcd, so direct etcd access skips authentication, RBAC, admission and audit logging.
  • By default the API server does not verify the kubelet's serving certificate; --kubelet-certificate-authority fixes that, and Konnectivity protects traffic across untrusted node networks.
  • API server proxy connections are plain HTTP by default; an https: prefix encrypts them but does not validate the endpoint's certificate.
  • Containers share the node's kernel; a RuntimeClass running gVisor or Kata Containers is the control that adds a separate kernel layer.
  • A static Pod survives kubectl delete of its mirror Pod; only deleting its manifest on the node removes it.
  • Controller-owned attacker Pods come back until the Deployment, DaemonSet or CronJob that owns them is deleted; mutating webhook configurations are a cluster-wide persistence point.
  • Deleting a legacy token Secret revokes that token; system:masters certificates bypass RBAC and cannot be revoked short of rotating the cluster CA.
  • Memory over the limit is OOMKilled, CPU over the limit is throttled; podPidsLimit caps a Pod's PIDs while systemReserved and kubeReserved PIDs protect daemons.
  • ResourceQuota is checked at admission and never removes existing Pods; priority-scoped quotas stop preemption abuse and FlowSchemas contain noisy API clients.
How the exam tests this

KCSA questions on this topic are mostly short definitions and scenarios from a threat modeller's or incident responder's point of view. Expect to identify which hop on a request's path is a trust boundary, which component talks to etcd and what direct etcd access bypasses, and which API server setting protects traffic to kubelets or what a proxy hop does and does not guarantee. Persistence questions describe something that keeps coming back or keeps working after a clean-up and ask what is causing it or what removes it: a static Pod, an owning controller, a mutating webhook, a legacy token or a system:masters certificate. Denial-of-service questions ask what happens when a container passes a CPU or memory limit, which kubelet setting contains a fork bomb, how ResourceQuota and LimitRange interact, how preemption can be abused, and how to contain a noisy API client. Distractors are real Kubernetes controls that act on the wrong resource, direction or scope, and some scenarios add an operational constraint that a heavier fix would break.

KCSA Compromised Containers, Network Attacks and Privilege Escalation

  • Code running in a container inherits exactly what its Pod holds: its service account token, volumes, Secrets, capabilities and network reach.
  • privileged: true, host namespaces, CAP_SYS_ADMIN and sensitive hostPath mounts are the main container-escape paths; hostPID shows the node's processes, hostNetwork its network, hostIPC its shared memory.
  • drop ALL removes default capabilities, allowPrivilegeEscalation: false sets no_new_privs against setuid gains, and neither replaces the other.
  • Mounting the node root, /var/lib/kubelet/pods or the container runtime socket exposes node credentials, neighbours' tokens or the whole node, bypassing the API server.
  • A service account token is a bearer credential worth exactly its RBAC; bound tokens limit theft through expiry, audience and Pod binding.
  • Secrets are only base64 in etcd until encryption at rest is configured; local providers keep the key in the config file, KMS v2 keeps it outside the cluster.
  • Without NetworkPolicy every Pod reaches every Pod and ClusterIP Service across namespaces; containment needs egress rules, and a 0.0.0.0/0 allow must except 169.254.169.254.
  • escalate, bind, impersonate, serviceaccounts/token and create on Pods are privilege-escalation permissions; Pod Security Admission does not stop a Pod borrowing a powerful service account in its namespace.
  • The Node authorizer confines a kubelet to its own node's Pods' objects and NodeRestriction limits what it can modify, so one compromised node exposes only its own Pods' Secrets.
How the exam tests this

KCSA questions on this topic take the attacker's point of view: a container, Pod, token or node has been compromised, and you are asked what the attacker can now reach or which control limits them. Expect to identify what privileged mode, a host namespace setting or a capability exposes; what a particular hostPath mount reveals; where the service account token lives and how far a stolen one goes; why base64 Secrets need encryption at rest and which provider survives theft of the control-plane config; and why env-var Secrets spread further than files. Network questions ask how far a compromised Pod reaches with no policies, across namespaces or to a ClusterIP, and what an ingress-only or broad egress policy still leaves open. Escalation questions name an RBAC grant or Pod-creation right and ask what it enables. Distractors are real Kubernetes controls that act on the wrong layer: RBAC offered for a network problem, Pod Security Admission for a borrowed service account, an ingress policy for egress, or a securityContext field that closes a different gap.

Platform Security

16% of the exam

KCSA Supply Chain Security, Image Registries and Admission Control

  • An SBOM lists components and versions (SPDX or CycloneDX); provenance records builder, source and build inputs; a signature proves which key or identity signed the image; a scan report lists CVEs known when it ran.
  • Stored SBOMs let a team find every image affected by a new CVE without pulling images; an old scan report cannot list a CVE published after it.
  • When a signing key is shared, only signed provenance from the CI builder proves an image came from CI and the expected repository.
  • In keyless signing, Fulcio issues a short-lived certificate from an OIDC identity and Rekor logs the event with a trusted timestamp, which is why signatures verify after the certificate expires.
  • Signatures only matter if an admission policy (Kyverno verifyImages, Sigstore policy-controller, Gatekeeper with external data) checks them, and that policy should rewrite the Pod to the verified digest because tags are mutable.
  • imagePullSecrets are resolved in the Pod's namespace; a ServiceAccount's imagePullSecrets are copied into its Pods; kubelet credential provider plugins fetch short-lived registry tokens on demand.
  • Nodes should pull with a pull-only account limited to the projects they need; tag immutability stops tags being overwritten, and scan-and-block stops vulnerable images being served.
  • AlwaysPullImages forces imagePullPolicy: Always so cached private images cannot be reused without credentials; NetworkPolicy cannot restrict registries because the node, not the Pod, pulls.
  • Mutating admission runs before validating admission, so validators see injected changes; admission never re-checks existing objects, reads or node-local restarts, so use Gatekeeper audit or Kyverno background scans.
  • failurePolicy Fail is fail-closed and Ignore fail-open, a timeout counts as a failure, and fail-closed webhooks should exclude their own namespace and kube-system to avoid lockout.
How the exam tests this

KCSA questions on this topic are mostly short definitions and scenarios from a platform security engineer's point of view. Expect to identify what each kind of supply chain evidence contains, name the standard SBOM formats, and explain the roles of the Sigstore components in keyless signing. Scenario items describe a gap somewhere between build, registry, admission and the node's image cache, and ask which control closes it. Admission questions cover the order of the admission phases, what admission does and does not re-check, how webhook failure and timeout settings behave, how to avoid locking a cluster out, and which policy mechanism fits a stated need. Distractors are real Kubernetes or registry features that act at the wrong layer, on the wrong object or at the wrong time.

KCSA Observability, Service Mesh, PKI and Secure Connectivity

  • Pick the signal by what the attack changes: metrics for resource abuse, traces for one request across services, audit for Kubernetes API calls, runtime detection for processes inside containers.
  • Container logs are deleted with the Pod; a node agent must forward them to an external backend, using credentials that can append but not delete.
  • Falco watches system calls and alerts without blocking; seccomp, AppArmor or SELinux prevent, and a person or response tool acts on the alert.
  • Mesh mTLS encrypts traffic and authenticates both workloads through proxies; identity is a SPIFFE ID from namespace and ServiceAccount, so give each workload its own ServiceAccount.
  • Istio defaults to PERMISSIVE; STRICT PeerAuthentication rejects plaintext, so move every client into the mesh before enforcing it. DestinationRules configure only client proxies.
  • Mesh policy can match identity, method and path; NetworkPolicy works at L3/L4 and still applies if a container with NET_ADMIN bypasses its sidecar.
  • kubeadm uses separate cluster, etcd and front-proxy CAs; leaf certificates last one year and CAs ten, renewed by upgrades or kubeadm certs renew; kubelets rotate client certificates with rotateCertificates.
  • A stolen CA key means replacing the CA and reissuing every certificate, because Kubernetes cannot revoke client certificates.
  • kubeadm join pins the CA with --discovery-token-ca-cert-hash; bootstrap tokens expire after 24 hours by default.
  • Konnectivity tunnels control plane traffic through agent-opened connections; CNI WireGuard or IPsec encrypts node-to-node traffic but authenticates only nodes; Ingress TLS ends at the controller.
How the exam tests this

KCSA questions on this topic are mostly short definitions and scenarios from a platform security engineer's point of view. Observability items describe an attack or an investigation and ask which signal can see it, how long built-in log data survives, how to keep logs trustworthy as evidence, and what runtime detection does when a rule matches. Service mesh items test what mTLS adds and how a mesh provides it, where workload identity comes from, how the mTLS modes behave during a migration, and when identity- or request-level policy is needed rather than NetworkPolicy. PKI items test the purpose of each cluster CA, certificate lifetimes, renewal and rotation, cert-manager issuer scope, the impact of a stolen CA key, and how nodes join safely. Connectivity items test which tool protects which network path and what each one does and does not authenticate or encrypt.

Compliance and Security Frameworks

10% of the exam

KCSA Compliance Frameworks, Threat Modeling and Supply Chain Compliance

  • CIS Level 1 is a low-impact baseline and Level 2 adds defence in depth that may limit functionality; Automated or Manual is a separate tag about how a check is assessed.
  • On a managed service, assess against the provider's CIS benchmark (EKS, AKS, GKE), because the customer cannot see or fix the provider-run control plane.
  • kube-bench runs on the host (a Job with hostPID and read-only hostPath mounts, or a binary) because node checks read files and process flags; WARN means a manual check a person must verify.
  • The NSA/CISA guidance explains threats and practices; the CIS Benchmark lists numbered, auditable settings. NIST SP 800-190 covers image, registry, orchestrator, container and host OS risks.
  • CSF 2.0 has six functions; Govern is new and holds supply chain risk management, which sat under Identify in CSF 1.1.
  • Regulations state outcomes, not Kubernetes settings; PCI DSS scope includes everything connected to or able to affect card data systems, and segmentation is what shrinks it.
  • A compliance report is point-in-time: drift needs scheduled checks on every node, alerts on new failures and retained timestamped results.
  • Threat model during design from a data flow diagram with trust boundaries, and revisit it whenever a new flow or component appears.
  • STRIDE maps to properties (spoofing-authentication, tampering-integrity, repudiation-accountability, disclosure-confidentiality, DoS-availability, elevation-authorization); ATT&CK tactics are goals and techniques are methods.
  • SLSA Build L1 = provenance exists, L2 = hosted platform signs it, L3 = isolated runs and signing secrets out of reach of build steps; Gatekeeper audit/dryrun and Kyverno Audit with background scans report on existing resources without blocking.
How the exam tests this

Questions in this topic are short scenarios that ask you to pick the framework, document or tool that fits a stated need, to classify a threat with STRIDE or a MITRE ATT&CK tactic, or to place a build setup on the SLSA Build track. Expect near-twin distinctions: CIS levels versus Automated and Manual checks, the NSA/CISA guidance versus the CIS Benchmark, tactics versus techniques, SLSA Level 2 versus Level 3, in-toto layouts versus link metadata, and Gatekeeper audit versus Kyverno policy reports. Some scenarios hinge on where a setting lives (host configuration versus API objects) or on the difference between a point-in-time report and continuous evidence.

Facts fresh? Prove it.
Drill KCSA practice questions with an explanation on every option.
Practice now

Where these KCSA facts came from

KCSA cheat sheet: your questions

Every key takeaway from all 13 KCSA revision lessons — 128 facts — pulled onto one page and grouped by exam domain, with the exam pattern behind each topic. It is a compression of the notes, not a separate set of content, so it can never contradict them.

Source

Exam structure, domain weights and scoring on this page come from the official KCSA exam guide.