← Back to blog

Kubernetes Security Assessment: What It Covers and How to Run One

November 3, 2026
Kubernetes Security Assessment: What It Covers and How to Run One

A Kubernetes security assessment is a structured review of how your clusters, workloads and surrounding infrastructure are configured and defended, ending in a prioritised list of fixes. It is not one activity. It can mean configuration scanning, an audit against a benchmark, threat modelling or a penetration test, and each produces different evidence. This guide explains what to include, how to choose between them and what to do with the results.

Solusec
solusec.co.uk
Find Kubernetes Weaknesses Before Attackers
Solusec provides expert-led penetration testing and practical findings to help you understand vulnerabilities across your Kubernetes environment.
Get a pentest quote

Key Takeaways

  • An assessment is a family of methods: scanning, audit, threat modelling and penetration testing answer different questions, so use more than one.
  • Start with configuration: privileged containers, host namespace sharing, over-broad permissions and flat networks are the usual first findings.
  • A penetration test is a point-in-time assurance exercise. The NCSC says it should not replace your normal security testing regime.
  • Findings only help if you triage them: fix, acknowledge or investigate, internet-facing and high-impact issues first, with dates recorded.
  • Scope the whole environment, not just the cluster boundary.

Table of Contents

What a Kubernetes security assessment actually is

The phrase covers several activities. One practitioner guide lists vulnerability scanning, audits, threat modelling, penetration testing and red-team exercises as the main types, each giving different evidence. The same guide makes a useful point: teams often treat these as rungs on a maturity ladder, when mature teams combine them.

In practice, think of three layers:

  1. Configuration review. Are the cluster, nodes and workloads set up safely? This is mostly automated checking plus human judgement.
  2. Image and supply chain review. What is inside the containers you run, and where did it come from?
  3. Adversarial testing. Can someone with realistic access actually break in, move sideways or reach data?

The first two tell you where the weaknesses are. The third tells you which ones an attacker can chain together.

Assessment or penetration test: which do you need?

If you search for Kubernetes penetration testing, you are really asking about the third layer. The NCSC describes penetration testing as gaining assurance by attempting to breach some or all of a system using tools and techniques an adversary might use. It also positions it as an assurance method within vulnerability management, not the main way of finding vulnerabilities, and warns that it only shows systems were not vulnerable to known issues on the day of testing.

That gives a sensible order of work:

MethodQuestion it answersBest used
Configuration scanningIs anything obviously misconfigured?Continuously, in the pipeline
Benchmark auditHow far are we from a recognised baseline?Before a first test, and after major changes
Threat modellingWhat could go wrong, and which controls matter most?At design stage and when architecture changes
Penetration testCan a realistic attacker get through?After the basics are fixed, then regularly

A penetration test run against a cluster full of basic misconfigurations mostly rediscovers what a scanner would have told you for free. Fix the obvious first and you get far more from the tester's time. If you want the distinction in more depth, our guide to the difference between a penetration test and a vulnerability scan covers it.

Scoping: the cluster is not the boundary

Kubernetes' own documentation, discussing NSA and CISA hardening guidance, says the threat model should include the underlying infrastructure and surrounding workloads that Kubernetes does not manage, not only the cluster boundary. A good scope therefore usually names:

  • the control plane and API server exposure (managed or self-hosted)
  • worker nodes and their operating systems
  • namespaces, workloads and service accounts
  • network policies and ingress points
  • container registries and build pipelines
  • secrets handling and any cloud IAM roles the cluster uses
  • the applications themselves, including web front ends and APIs

The NCSC says scoping for a penetration test should document technical boundaries, types of test, timeframe and effort, and any scenarios or use cases. Write these down before anyone touches a keyboard. If your cluster runs on AWS or Azure, the cloud account around it matters as much as the cluster, which is why we pair this work with a cloud security assessment.

What to check: the main risk areas

Privileged workloads and host access

Google's documentation for GKE security posture scanning treats privileged containers as a high-severity concern: they allow nearly unrestricted host access and lack standard security restrictions. It rates sharing host namespaces (hostNetwork, hostIPC, hostPID) the same way, because container processes can then interact with host processes and gather host information, which may lead to container escape. The principle applies to any distribution, not just GKE.

Running as a low-privilege user

NCSC containerisation guidance recommends running containers as a low-privilege user, avoiding privileged containers, preferring read-only filesystems and applying network access controls. These are quick to check across every workload and quick to enforce with admission policy.

Images and the supply chain

The NCSC recommends scanning container images for malware, known vulnerabilities, misconfiguration and credentials throughout their lifecycle. Credentials baked into images are a particularly common and costly find, because anyone who can pull the image can read them.

Permissions, secrets and network flows

A review should map who and what can do what: RBAC roles, service account tokens, secrets access and cloud roles. Then check whether pods can talk to anything they like. Flat networks turn one compromised pod into a foothold across the whole cluster.

Isolation limits

Containers share a kernel. The NCSC notes that kernel-enforced separation such as containerisation does not provide strong separation and suggests options like hypervisor-enforced separation when strong separation is needed. If you host workloads for different customers or trust levels in one cluster, ask whether namespaces are enough.

A Kubernetes hardening checklist to start from

Use this as a first pass before commissioning outside help. It draws on NCSC and UK government guidance.

  • Operating systems: vendor-supported and hardened to an industry benchmark. The UK government's containerisation security standard asks for exactly this.
  • Users: images configured to run as non-privileged users where technically possible.
  • Filesystems: read-only container filesystems by default, with writable paths declared deliberately.
  • Privilege: no privileged containers and no host namespace sharing without a documented reason.
  • Network: default-deny network policies, then allow what each workload needs.
  • Images: scanned at build and again in the registry and at runtime.
  • Secrets: kept out of images and manifests; access limited per workload.
  • Logging: audit logs enabled and tuned to threats you actually need to detect.

A caution from the NCSC applies here: moving an existing application into a container without adapting it is unlikely to yield security benefits and may worsen your posture. A checklist helps, but design choices matter more.

How to check a cluster yourself

Open-source tooling gets you a long way. Trivy's Kubernetes mode can scan a whole cluster or specific workloads for vulnerabilities and misconfigurations. Benchmark tools such as kube-bench check nodes against the CIS Kubernetes Benchmark. Run them, export the results and treat the output as a starting list, not a verdict.

Expect noise. Kubernetes' guidance on hardening is clear that automated scanning and admission controls are useful but policies must allow for exceptions, context and false positives, and that security decisions should follow your threat model. A scanner cannot tell you that a flagged privileged pod is a legitimate node agent, or that a clean report hides an exposed dashboard.

How to check a cluster yourself

What a Kubernetes penetration test involves

The NCSC outlines a typical test as initial engagement, scoping, testing, reporting and follow-up. For a Kubernetes target, testers commonly work from realistic starting points:

  1. External view: what the internet can reach, such as ingress, exposed dashboards, the API server and the applications behind them.
  2. Compromised workload: assume an attacker has code execution in one pod. Can they read service account tokens, reach other namespaces, hit the kubelet or the metadata service?
  3. Compromised credentials: what can a developer's stolen kubeconfig or CI token do?
  4. Escape and escalation: can a weak workload setting lead to the node, then to the cluster or the cloud account?

The report should list the issues found, their risk levels, methods of resolution and an opinion on the accuracy of your own vulnerability assessment. Insist on plain-English findings with proportionate, specific fixes, and a retest of the items you remediate. Web and API layers on top of the cluster are often where attackers start, so they are worth including through web application and API testing and, for exposed nodes and networks, infrastructure testing.

Turning findings into fixes

A long report is only useful if someone owns it. The NCSC's vulnerability management guidance suggests you consolidate similar findings, triage them as fix, acknowledge or investigate, and prioritise internet-facing and high-impact vulnerabilities. It also advises recording fix dates, time-bounding and tracking temporary mitigations, and documenting acknowledged issues with a rationale and review date.

A workable routine for a small team:

  • Group findings by root cause. Fifty pods running as root is one policy fix, not fifty tickets.
  • Put internet-facing and credential-exposure issues first.
  • Give each item an owner and a date.
  • Where you cannot fix now, record the compensating control and a review date.
  • Retest after fixing, then add the check to your pipeline so it stays fixed.

Because a test is a snapshot, pair it with ongoing checks. Vulnerability management covers the continuous side, and continuous penetration testing suits teams that ship changes weekly.

How we can help

Solusec is a CREST-accredited penetration testing company. You work directly with the testers who do the work, not a sales team, and findings come in plain English with fixes sized to your organisation. That matters for startups, schools, colleges and charities that do not have a dedicated platform security team.

Solusec

Our published penetration testing prices start with an external IP test at £3,000 and a CMS website test at £2,500, both one-off. Kubernetes and container environments are scoped individually, so tell us what you run and where, and we will agree the scope with you. See our penetration testing services or get in touch via our main site. If a customer or insurer is also asking for a baseline certification, we are a certification body for Cyber Essentials too.

FAQ

Is a Kubernetes security assessment the same as a penetration test?

No. An assessment is the wider review, which can include scanning, audit and threat modelling. A penetration test is one part of it, where testers attempt to breach the environment as an adversary would. Most organisations get the best results by doing the configuration work first, then testing.

How often should we assess our clusters?

Continuous scanning should run in your pipeline and against live clusters. A penetration test is commonly repeated at least annually and after significant changes such as a new ingress design, a cloud migration or a major release. The NCSC notes a test only reflects the day it was run, so avoid relying on one report for long.

What does a container security assessment cover?

It covers the images, the registry and build pipeline, and how containers run. That means scanning images for vulnerabilities, malware, misconfiguration and embedded credentials, then checking runtime settings such as user privileges, filesystem access and network controls.

Do small organisations need this?

If you run production workloads or hold personal data in Kubernetes, yes, in proportion to your risk. A small team can start with the hardening checklist and open-source scanning, then commission a scoped test of the most exposed parts.

Sources

This article was created with assistance of AI. We never use AI with your data unless given explicit permission.