SaveMyCert
Log in
5 of 5 free questions left today·for 10 a day
Platform Security

KCSA Observability, Service Mesh, PKI and Secure Connectivity

19 min readKCSA · Platform SecurityUpdated

Platform observability, service mesh, PKI and connectivity are the Kubernetes security controls that let you see attacks, prove which workload is talking, keep the cluster's certificates trustworthy and protect traffic on every network path. This lesson covers which signal (logs, metrics, traces, audit or runtime events) sees which attack, keeping logs as evidence, runtime threat detection with Falco, service mesh mTLS and SPIFFE workload identity, PERMISSIVE versus STRICT mode, mesh policy versus NetworkPolicy, the three kubeadm CAs, certificate expiry and rotation, cert-manager, CA key compromise and join-time CA pinning, Konnectivity, CNI node encryption and Ingress TLS termination.

What you’ll learn
  • Match logs, metrics, traces, audit events and runtime events to the attacks each one can and cannot reveal
  • Explain why container logs must be shipped off-node with append-only credentials, and why Falco alerts rather than blocks
  • Describe how a service mesh adds mTLS without app changes, how workload identity derives from the ServiceAccount, and how to migrate from PERMISSIVE to STRICT safely
  • Compare mesh authorisation with NetworkPolicy and explain why NetworkPolicy stays as defence in depth
  • Identify the cluster, etcd and front-proxy CAs, and manage certificate expiry with kubeadm, kubelet rotation and cert-manager
  • Respond to a stolen CA key and explain how CA pinning and short-lived tokens protect kubeadm join
  • Choose between Konnectivity, CNI WireGuard or IPsec encryption, mesh mTLS and Ingress TLS for a given connectivity requirement

What observability means for cluster security

Security observability is collecting the signals that let you notice an attack while it happens and reconstruct it afterwards: logs, metrics, traces, API audit events and runtime events. Each signal sees a different slice of the cluster, so the first skill is matching the question you need answered to the signal that can answer it.

SignalWhat it recordsWhat it cannot seeTypical tools
Container and node logsWhat applications and components write to stdout, stderr and log filesAnything the process does not choose to logFluent Bit, Fluentd, Vector, a log backend
MetricsNumbers over time: CPU, memory, request rates, error ratesWhich process or user caused a changePrometheus (metrics-server holds only current usage, with no history)
Distributed tracesOne request's path across services, as linked spans sharing a trace IDUninstrumented services and non-request activityOpenTelemetry, Jaeger
API server audit eventsWho sent which request to the Kubernetes API, and the outcomeTraffic between workloads, and what happens inside a containerThe audit policy and audit backends (see the authentication, Secrets and auditing lesson)
Runtime eventsProcesses started, files opened, network connections made, seen through kernel system callsIntent and business context; it sees behaviour, not meaningFalco, eBPF-based sensors

A useful habit is to ask what does this attack actually change? Resource abuse such as cryptomining may never touch the Kubernetes API or write to a log, so audit and application logs miss it, yet it moves CPU and memory far from their baseline, which is why metrics tend to notice it first. Following a single request as it hops from a web frontend to an orders service and on to an inventory service is the job of distributed tracing, because each service passes the trace ID along and the spans join into one trace. Metrics aggregate across requests, and audit events cover only calls to the Kubernetes API.

The same reasoning applies to kubectl exec. Opening the shell is an API request (pods/exec), so the audit log records who opened it, on which Pod, with which initial command. The keystrokes and the commands typed afterwards travel inside the streamed connection and never appear in the audit log, whatever its level. Only a runtime tool that watches process execution in the kernel sees each command. Investigators need both sources together.

Keeping logs as evidence: cluster-level logging

Kubernetes has no built-in long-term log storage: container logs live in files on the node and are removed with the Pod, so evidence survives only if a cluster-level logging solution has already shipped it elsewhere. The container runtime writes each container's stdout and stderr to files on the node, and the kubelet rotates them (containerLogMaxSize and containerLogMaxFiles in its configuration). kubectl logs reads those files through the kubelet.

The principle: every built-in way to read container output depends on those node files existing. kubectl logs --previous reaches the last instance of a restarted container, but only while its Pod still exists. Nothing in the control plane keeps a copy of the output: Events are brief status summaries retained for one hour by default, and etcd stores API objects, not log lines.

So if an attacker's Pod is deleted during incident response and no logging add-on was running, its output is gone. The standard pattern is a node logging agent, usually a DaemonSet, that tails the log files on every node and forwards them continuously to a backend outside the cluster.

Making logs tamper-resistant

Root on a node can change anything stored on that node: rotated log files, hostPath directories and any volume mounted there. Any copy that stays reachable from the node, however long it is kept and wherever it is mounted, is within reach of an attacker who gains root there. Tamper resistance therefore comes from getting the record off the node and out of the attacker's authority:

  • Forward promptly to a store that runs outside the cluster, so history leaves the node before an attacker arrives.
  • Give the forwarder append-only credentials: it can write new entries but cannot delete or overwrite old ones. A stolen node credential then cannot destroy history.
  • Protect the backend with its own access control and retention, separate from cluster administration.

Runtime threat detection with Falco

Runtime threat detection watches what running containers actually do, usually by observing kernel system calls on each node, and raises an alert when behaviour matches a suspicious rule. Falco, a CNCF graduated project, is the reference example: it runs on every node (typically as a DaemonSet), uses a kernel driver or eBPF probe to see events such as process execution, file opens and network connections, enriches them with container and Kubernetes metadata, and evaluates them against rules. Its default rules include, for example, a shell starting inside a container and reads of sensitive files.

Because it observes the kernel, runtime detection needs no change to images or applications, and it catches behaviour that earlier controls cannot. Compare where each control acts:

ControlWhen it actsWhat it can catch
Image scanner (Trivy, Grype)Before deploymentKnown CVEs in packages
Admission controller (Gatekeeper, Kyverno, Pod Security Admission)When a Pod is createdRisky Pod specs
Runtime detection (Falco)While the container runsBehaviour: a shell, an unexpected binary, a write to a system path
MetricsContinuouslyLevels of resource use, not which process ran

Detection is not prevention

Falco alerts; it does not block. When a rule matches, it sends an event to its configured outputs (stdout, files, HTTP endpoints, or Falcosidekick to fan alerts out to chat, SIEM and other tools). The shell it reports keeps running until something responds. Stopping behaviour is a different control: seccomp profiles or an enforcing Linux security module (AppArmor, SELinux) prevent system calls and file access, and a person or an automated response tool acts on the alert, for example by deleting the Pod. Expect exam scenarios to separate "notice it" from "stop it".

Service mesh mutual TLS and workload identity

A service mesh adds mutual TLS (mTLS) between workloads, which encrypts traffic in transit and lets both sides prove which workload they are, without any TLS code in the applications. In ordinary TLS only the server presents a certificate; in mTLS the client presents one too, so each side authenticates the other.

The mesh does this with a proxy in the data path of every workload. In Istio's sidecar mode, each Pod gets an Envoy sidecar, and traffic redirection rules (written by an init container or the Istio CNI plugin) send the application's plain connections through it. The client's proxy and the server's proxy perform the mTLS handshake with each other. In sidecar-less modes such as Istio ambient, a per-node proxy (ztunnel) does the same job for the Pods on that node, with optional waypoint proxies for Layer 7 policy.

The mesh control plane (istiod in Istio) acts as a certificate authority: it issues each workload a short-lived certificate and rotates it automatically, so no human handles these keys. What mTLS gives, and what it does not:

  • Gives: encryption of Pod-to-Pod traffic, and verified workload identity on both ends, which identity-based authorisation policies build on.
  • Does not give: end-user authentication (that is a separate request-level JWT check), Kubernetes RBAC checks, or inspection of payloads for malicious content.

Workload identity: SPIFFE IDs and ServiceAccounts

In Istio on Kubernetes, a workload's identity is its Kubernetes ServiceAccount, encoded in its certificate as a SPIFFE ID of the form spiffe://<trust-domain>/ns/<namespace>/sa/<serviceaccount>. SPIFFE is the CNCF standard for workload identity, and SPIRE is its reference implementation that issues such identities outside a mesh as well. Authorisation policies refer to this identity as the caller's principal.

Pod IPs, node names and image names make poor identities: IPs are reused, many Pods share a node, and the same image can run in many roles. A ServiceAccount is stable and is something you deliberately assign.

The practical consequence: give each workload its own ServiceAccount. A Pod that omits serviceAccountName runs as its namespace's default ServiceAccount. Every workload in a namespace that relies on that account carries the same identity, so no authorisation policy can treat them differently. RBAC bindings govern what an account may do against the Kubernetes API; they do not change its mesh identity. Separate ServiceAccounts give separate principals and also follow least privilege for API access.

PERMISSIVE and STRICT mTLS, and migrating safely

By default Istio accepts both mTLS and plaintext at each workload (PERMISSIVE mode); a PeerAuthentication policy with mode STRICT makes the server's proxy refuse anything that is not mTLS. PERMISSIVE exists so that a team can adopt the mesh gradually without breaking clients that do not yet have a proxy. The flip side is that a Pod without a sidecar can still send plain HTTP to a meshed Pod and get an answer.

ResourceSide it configuresWhat it controls
PeerAuthentication (PERMISSIVE, STRICT, DISABLE)Server (receiving workload)Which connections the workload accepts
DestinationRule (TLS mode such as ISTIO_MUTUAL)Client proxyHow a proxy originates connections to a destination
AuthorizationPolicyServerWhich principals, namespaces, methods and paths are allowed or denied

A PeerAuthentication can be mesh-wide (in the root namespace), per namespace, or per workload via a selector. Two facts drive safe migration:

  1. STRICT makes the server refuse plaintext immediately.
  2. In a mesh, a client gets its mesh certificate and speaks mTLS through its proxy (a sidecar or ambient ztunnel). A DestinationRule configures that proxy, so it does nothing for a workload that has none.

So the order is: bring the remaining plaintext clients into the mesh, confirm their calls now arrive as mTLS, and only then switch the destination to STRICT. Switching first breaks the legacy client. The general rule: STRICT is enforced by the receiving proxy and judges only whether the connection is mTLS, so the fix must make the client speak mTLS. Controls that allow traffic by address or by principal cannot make a plaintext connection acceptable, and a plaintext caller has no verified principal to match.

Mesh authorisation versus NetworkPolicy

A mesh authorisation policy can allow or deny traffic by the caller's verified identity and by Layer 7 attributes such as HTTP method and path; a NetworkPolicy works only at Layers 3 and 4 (Pods, namespaces, IP blocks, ports and protocols). A rule such as "the dashboard may only read GET /status on the inventory service" needs the mesh, because a NetworkPolicy never sees methods or paths. RBAC and Pod Security Admission are not traffic controls at all: they govern requests to the Kubernetes API and the contents of Pod specs.

NetworkPolicyMesh AuthorizationPolicy
Enforced byThe CNI plugin, in the node's network stackThe workload's proxy
Identifies callers byPod and namespace labels, IP blocksCryptographic workload identity from mTLS
Can match HTTP method and pathNoYes (with a proxy that handles Layer 7)
Encrypts trafficNoYes, together with mTLS
Bypassed if the proxy is bypassedNoYes

The last row is why you keep both. In sidecar mode, the redirection to the proxy is just iptables (or similar) rules inside the Pod's network namespace. A container in that Pod that holds the NET_ADMIN capability can rewrite or delete those rules and send traffic straight out, skipping the proxy and every policy it enforces. NetworkPolicy, enforced outside the Pod, still applies. So app containers should not get NET_ADMIN, and NetworkPolicy remains a defence-in-depth layer beneath the mesh. (NetworkPolicy semantics themselves are covered in the network policy lesson.)

Cluster PKI: the three kubeadm CAs

A kubeadm cluster uses three separate certificate authorities: the cluster CA for the Kubernetes API, an etcd CA, and a front-proxy CA for the API aggregation layer; keeping them separate stops a certificate meant for one purpose from being accepted for another. Their keys and certificates live under /etc/kubernetes/pki on control plane nodes.

CASignsTrusted by
Cluster CA (ca.crt)API server serving cert, kubelet client certs, admin and component kubeconfigs, user client certsThe API server (as --client-ca-file), kubelets, kubectl clients
etcd CA (etcd/ca.crt)etcd serving and peer certs, the API server's etcd client certetcd only
Front-proxy CA (front-proxy-ca.crt)The API server's front-proxy client certExtension (aggregated) API servers, via --requestheader-client-ca-file

Why a separate etcd CA: etcd holds every object, including Secrets. If it trusted the cluster CA, any of the many certificates that CA issues to users and nodes could open a direct connection to etcd. With its own CA, only the etcd members and the API server's etcd client certificate are trusted there. The API server still authenticates to etcd with a client certificate; it just comes from the etcd CA.

Why a separate front-proxy CA: when the API server forwards a request to an aggregated extension API server, it authenticates with a client certificate and passes the end user's name and groups in headers (X-Remote-User, X-Remote-Group). The extension server believes those headers only from clients signed by its request-header CA. If that were the cluster CA, any ordinary user with a client certificate could connect directly and set the headers to claim any identity.

Separate from all three is the service account signing key pair (sa.key, sa.pub), which signs ServiceAccount tokens. Encryption-at-rest keys and image-signing keys are different keys again; the cluster CA does none of those jobs.

Certificate lifetimes, expiry and rotation

kubeadm issues the control plane's certificates for one year and its CAs for ten years, so a cluster left untouched for a year fails with x509 "certificate has expired" errors unless those certificates are renewed. The one-year certificates include the API server, etcd and front-proxy certificates, the component client certificates and the kubeconfig files such as admin.conf.

  • kubeadm certs check-expiration lists each certificate and CA with its expiry date.
  • kubeadm upgrade apply and kubeadm upgrade node renew the certificates as part of an upgrade, which is why regularly upgraded clusters rarely hit this.
  • kubeadm certs renew all (or a named certificate) renews them by hand; the control plane static Pods must then be restarted to load the new files.

Kubelet certificates

Each kubelet authenticates to the API server with a client certificate that also expires. With rotateCertificates: true in the kubelet configuration (kubeadm sets this), the kubelet creates a CertificateSigningRequest as expiry approaches, the request is approved and signed, and the kubelet loads the new certificate. Without it, nodes go NotReady when their certificates expire until someone reissues them by hand.

The kubelet's serving certificate, which it presents to the API server for logs and exec, is separate. serverTLSBootstrap: true makes the kubelet request it through the certificates API too, but the built-in controller does not auto-approve serving CSRs, so an administrator or a dedicated approver must approve them. (How the API server verifies the kubelet is covered in the control plane and kubelet lessons.)

Automating application certificates with cert-manager

For certificates that workloads and Ingresses use, cert-manager (a CNCF project) manages certificates as Kubernetes resources. A Certificate resource names the DNS names and an issuer; cert-manager requests the certificate from an ACME CA such as Let's Encrypt, a private CA, Vault or another issuer, stores it in a kubernetes.io/tls Secret, and renews it before it expires. Automated renewal makes short lifetimes practical, which shrinks the window in which a stolen certificate is useful.

cert-manager kindScopeCan sign for
IssuerNamespacedCertificates in its own namespace only
ClusterIssuerCluster-wideCertificates in any namespace, referenced with issuerRef.kind: ClusterIssuer

A shared issuer for many teams is therefore a ClusterIssuer. An issuer's reach is set by its kind: a Certificate can only use a namespaced Issuer from its own namespace, so signing across namespaces needs a ClusterIssuer. Other certificate tools have different jobs: the Notary Project and Sigstore sign artifacts such as images, and SPIRE issues workload identities.

When the CA key is stolen, and pinning the CA when nodes join

A stolen cluster CA private key lets an attacker sign a client certificate for any user and group that the API server will accept, and because Kubernetes has no revocation for client certificates, the only fix is to replace the CA and reissue everything it signed. Certificate authentication trusts whatever the CA signs, so an attacker can mint a certificate in the system:masters group, which bypasses authorisation entirely. Its reach is limited to what certificate trust covers; the cluster's other keys (see the PKI section above) each have their own job.

Responding to a CA compromise takes two things together:

  1. Replace the CA with a new key pair and remove the old CA from every trust bundle (API server, kubelets, kubeconfigs, webhooks), so certificates signed offline by the attacker stop verifying.
  2. Reissue every legitimate certificate and kubeconfig from the new CA.

Kubernetes documents a staged manual CA rotation (trust old and new together, move components over, then drop the old) so this can be done without downtime. The attacker's power comes from the private key itself, so any response that leaves the old key trusted, whatever it changes about validity periods, signing settings or other keys, leaves the attacker's certificates valid.

Joining nodes safely

When a node runs kubeadm join, it authenticates with a bootstrap token and discovers the cluster by fetching its CA certificate from the API server. Two protections apply:

  • --discovery-token-ca-cert-hash sha256:... pins the CA's public key. The joining node continues only if the CA it is shown matches the hash, which defeats a fake API server on the network posing as the cluster. The flag --discovery-token-unsafe-skip-ca-verification turns this check off and should not be used.
  • Bootstrap tokens are short-lived: the token created by kubeadm init expires after 24 hours by default. The hash does not protect a leaked token; the short lifetime limits it. To join later, run kubeadm token create --print-join-command on a control plane node, which prints a fresh join command including the CA hash.

Secure connectivity: Konnectivity, node encryption and Ingress TLS

Secure connectivity means protecting the paths into, out of and across the cluster: control plane to nodes, Pod traffic between nodes, and client traffic arriving through Ingress. Each path has its own tool.

Control plane to cluster: Konnectivity

Some API features work by the API server connecting to the cluster: kubectl logs, exec and port-forward reach the kubelet, and the API server also calls webhooks and aggregated API servers. If the control plane sits in a separate network and the nodes accept no inbound connections from it, those calls fail even though Pods keep running. The Konnectivity service fixes this with a TCP-level tunnel: a Konnectivity server on the control plane and agents in the cluster that open outbound connections to it. The API server sends its control-plane-to-cluster traffic through that tunnel, so no inbound ports open on the nodes. It replaced the deprecated SSH tunnels.

Pod traffic between nodes: CNI encryption

Many CNI plugins can transparently encrypt Pod traffic between nodes using WireGuard (and, in some plugins, IPsec): Cilium offers both, and open source Calico offers WireGuard. It needs no application change and no sidecar. Its limit is identity: the tunnel endpoints are nodes, so every Pod on a node shares that node's key, and a receiver cannot cryptographically tell one calling workload from another. A strict mode that drops unencrypted packets still authenticates only nodes.

CNI WireGuard / IPsecService mesh mTLS
EncryptsPod traffic between nodesTraffic between workloads' proxies
AuthenticatesNodesEach workload (ServiceAccount identity)
Supports identity-based and L7 policyNoYes
Needs proxiesNoYes (sidecar or per-node)

So when a rule says a service must verify that each caller is a specific workload, node encryption is not enough; that calls for mesh mTLS plus an authorisation policy on the caller's identity.

Into the cluster: Ingress TLS

An Ingress serves HTTPS when its spec.tls lists hosts and a secretName. That Secret, normally of type kubernetes.io/tls with tls.crt and tls.key, must be in the same namespace as the Ingress. Because it holds the private key, anyone who can read Secrets in that namespace can impersonate the site, so keep that RBAC tight.

TLS terminates at the ingress controller. The controller's hop to the backend Pods is plain HTTP unless the controller re-encrypts to an HTTPS backend or a mesh applies mTLS on that hop. TLS ends wherever the certificate's private key is used, which is why the Secret sits with the Ingress rather than with the backends. If a rule says data must be encrypted on every hop, the controller-to-backend hop is the gap to close. For traffic leaving the cluster, egress NetworkPolicy and mesh egress gateways give a controlled, observable exit point.

Tip. 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.

Key takeaways
  • 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.

Check yourself: 3 questions on this topic

Exam-style KCSA questions on Observability, service mesh, PKI and connectivity, answered right here with an explanation after each. Want more? KCSA Platform Security practice questions.

Frequently asked questions

Which signal shows the commands typed inside a kubectl exec session?

Runtime threat detection, such as Falco watching process execution on the node, shows each command typed inside a kubectl exec session. The Kubernetes audit log records the pods/exec request itself, including who opened the session, the Pod and the initial command, but the keystrokes and later commands travel inside the streamed connection and are never written to the audit log.

Does Falco stop an attack it detects?

No. Falco is a detection tool: it watches kernel system calls on each node, matches them against rules and sends alerts to its configured outputs, while the offending process keeps running. Prevention comes from seccomp profiles or enforcing Linux security modules such as AppArmor and SELinux, and response comes from a person or an automated tool that acts on the alert.

What is the difference between PERMISSIVE and STRICT mTLS in Istio?

PERMISSIVE, Istio's default, lets a workload accept both mutual TLS and plaintext connections so that clients without a sidecar keep working during migration. STRICT, set with a PeerAuthentication policy, makes the workload's proxy reject anything that is not mTLS. Move every client into the mesh and confirm it sends mTLS before switching a service to STRICT.

How does Istio identify a workload?

Istio identifies a workload by its Kubernetes ServiceAccount. The workload's certificate carries a SPIFFE ID of the form spiffe://trust-domain/ns/namespace/sa/serviceaccount, and authorisation policies match that principal. Pods that omit serviceAccountName all run as their namespace's default ServiceAccount and therefore share one identity, so each workload should have its own ServiceAccount.

Why does kubeadm use a separate CA for etcd?

kubeadm gives etcd its own certificate authority so that etcd trusts only its members and the API server's etcd client certificate. Certificates issued by the main cluster CA to users, nodes and components cannot open a direct connection to etcd, which stores every Kubernetes object including Secrets.

What should you do if the Kubernetes cluster CA private key is stolen?

Replace the cluster CA with a new key pair, remove the old CA from every trust bundle, and reissue every certificate and kubeconfig from the new CA. Kubernetes has no revocation for client certificates, so any certificate the attacker signed stays valid until the old CA is no longer trusted. Renewing the CA on the same key does not help.

Why do kubeadm clusters fail with expired certificate errors after a year?

kubeadm issues the API server, etcd, front-proxy and component certificates and the admin kubeconfig for one year, while the CAs last ten years. Control plane upgrades renew them automatically, so a cluster that is never upgraded hits x509 expiry errors after a year. kubeadm certs check-expiration shows the dates and kubeadm certs renew renews them by hand.

Is CNI WireGuard encryption a replacement for service mesh mTLS?

Not fully. CNI WireGuard or IPsec encryption protects Pod traffic between nodes without sidecars or code changes, but its endpoints are nodes, so it cannot prove which workload sent a request. Service mesh mTLS gives each workload its own certificate identity, which a receiving service can require in an authorisation policy.

Source

This lesson covers the "Platform Security" domain of the official KCSA exam guide. Vendors revise their guides — check the source for the current version.

Sign up free to mark lessons complete, bookmark topics and track your exam readiness.

Spotted a mistake in this lesson?