Screenata

Integrations / Cloud & infrastructure

Screenata + Kubernetes

How do you continuously monitor Kubernetes for SOC 2 and ISO 27001?

Quick answer

Yes, you can run a SOC 2, ISO 27001, or HIPAA compliant workload on Kubernetes, but Kubernetes itself is not the thing that gets audited. Kubernetes is open-source software with no vendor attestation behind it; where the cluster runs on a managed service, the cloud provider certifies the infrastructure under it and publishes reports for that layer only. Your cluster configuration, RBAC bindings, pod security settings, network policies, and secret handling are yours to get right and yours to evidence. Screenata runs 10 native checks against that configuration on a schedule and turns each result into signed evidence mapped to the control it satisfies.

Screenata connects to Kubernetes with read-only service account access and runs 10 native checks against cluster configuration: API server, etcd, kubelet, RBAC, and pod security settings. Each finding becomes a signed, timestamped evidence artifact mapped to SOC 2, HIPAA, and ISO 27001 controls through a shared control catalog.

10 native checks · read-only · signed evidence

What it proves

Kubernetes evidence, mapped to controls.

Each area below is scanned on a schedule. A finding is not a green checkmark: it is a signed artifact an auditor can verify, mapped to the exact requirement it satisfies.
Evidence area
What the checks verify
Maps to
Control plane (API server & etcd)

API server and etcd configuration, verified against the settings your cluster hardening baseline expects.

Configuration snapshot showing the control plane settings in force on the scan date.

SOC 2CC8.1ISO 27001A.8.9
Cluster RBAC

RBAC configuration in the cluster, including how broadly privileged roles are bound.

Proof that cluster access follows least privilege and that privileged bindings are limited.

SOC 2CC6.3ISO 27001A.8.2
Node configuration (kubelet)

Kubelet configuration on cluster nodes, verified against expected secure settings.

Per-node findings showing kubelet settings match the configuration your controls describe.

SOC 2CC8.1ISO 27001A.8.9
Pod security

Pod security configuration, including whether workloads run under the restrictions your policies define.

Findings that workloads run inside the security boundaries the system description claims.

SOC 2CC6.6ISO 27001A.8.9

Control references are the requirements each evidence area supports, via the shared control catalog. Your auditor decides sufficiency; the artifacts are theirs to verify.

Compliance checks

What Screenata checks on Kubernetes, and why each matters.

Each row is a real native check, the framework control it produces evidence for, and the risk it closes. This is what continuous Kubernetes compliance actually looks like. Checks run on a schedule; a failing check opens a ticket and re-verifies after a human applies the fix.
Check & why it matters
Maps to

Cluster-Admin Bindings Limited

A subject bound to cluster-admin holds full control over every namespace, so an over-assigned binding turns one compromised account into total cluster takeover. An auditor checks that super-user bindings are limited to a named few and follow least privilege.

SOC 2CC6.1SOC 2CC6.3ISO 27001A.8.12

No Privileged Containers

A privileged container can control the host and break out of its isolation, letting one compromised pod reach the node and other workloads. An auditor verifies that user workloads do not run in privileged mode.

SOC 2CC6.1ISO 27001A.8.2

Containers Run as Non-Root

Containers running as root make privilege escalation and container breakout easier if the workload is compromised. An auditor verifies that containers enforce a non-root user.

SOC 2CC6.1ISO 27001A.8.2

Read-Only Root Filesystem

A writable root filesystem lets an attacker who lands in a container modify binaries and persist between restarts. An auditor verifies that containers mount their root filesystem read-only.

SOC 2CC6.1SOC 2CC8.1

Host Namespace Isolation

Pods that share the host network, PID, or IPC namespaces drop the isolation boundary between the workload and the node. An auditor verifies that workloads do not share host namespaces unless strictly required.

SOC 2CC6.1

Network Policies Configured

Without a network policy, any pod can reach any other pod, so a single compromise spreads laterally across the cluster. An auditor verifies that user namespaces restrict traffic with network policies.

SOC 2CC6.1

No Workloads in Default Namespace

Workloads in the default namespace are hard to scope with policy and inherit loose settings, weakening isolation and change control. An auditor verifies that workloads run in dedicated namespaces.

SOC 2CC6.1SOC 2CC8.1

Service Account Token Auto-Mount Disabled

A pod that auto-mounts the default service account token carries API credentials it does not need, widening what a compromised container can reach. An auditor verifies that default service accounts disable token auto-mount.

SOC 2CC6.1

No Secrets Exposed as Environment Variables

Secrets passed as environment variables leak through logs, process dumps, and debug endpoints, exposing the credentials that guard data. An auditor verifies that secrets are mounted as files rather than set as env vars.

SOC 2CC6.1SOC 2CC7.1

Containers Drop All Capabilities

Containers that keep the default Linux capabilities carry more kernel privileges than they need, raising the impact of a breakout. An auditor verifies that containers drop all capabilities and add back only what is required.

SOC 2CC6.1

Drawn from Screenata’s Kubernetes check library. Control refs are the requirements each check produces evidence for; your auditor decides sufficiency.

How it connects

Read-only, revocable, yours.

You provide a kubeconfig or a cluster service account with read access, and Screenata uses it for scheduled scans. Vera never receives write access to your clusters, and credentials never touch the Screenata database. Weekly cloud scans run automatically; findings are hashed and stored as evidence the moment they land.

Read-only by construction

OAuth scopes and IAM roles are scoped to read. Vera never gets write access to your systems.

Signed findings

SHA-256 per artifact, RSA/ECDSA signatures, RFC 3161 timestamps. Verifiable without a Screenata account.

Mapped to controls

Each finding lands on the shared control catalog, so one scan satisfies SOC 2, HIPAA, and ISO 27001 at once.

BAA & attestation status

There is no vendor to sign a BAA for Kubernetes, because Kubernetes is open-source software you operate rather than a service you buy. The compliance obligation for the cluster is entirely yours. If the cluster runs on a managed service such as EKS, AKS, or GKE, the cloud provider's BAA covers the infrastructure beneath it, not your workloads or your cluster configuration.

Kubernetes FAQ

What teams ask before connecting.

Full provider list on the integrations page.
What access does Screenata need to my Kubernetes cluster?

Read access through a kubeconfig or a cluster service account that you create and control. Screenata uses it for scheduled scans and never receives write access. You can scope it yourself and revoke it at any time.

How often do the Kubernetes checks run?

On a schedule, with weekly cloud scans as the default cadence. Each run produces fresh findings, and evidence freshness is tracked so anything approaching staleness gets flagged before an auditor sees it.

What happens when a Kubernetes check fails?

Vera opens a ticket describing the failing configuration and re-verifies after a human applies the fix. Nothing in your cluster is changed by Screenata; the connection is read-only by construction.

What are the steps to implement SOC 2 with Kubernetes?

First, connect the cluster read-only with a kubeconfig or a scoped service account so the scan can see your configuration without any write path. Second, let the first scan run and establish a baseline of where the cluster stands against the SOC 2 control set, instead of guessing which controls are already met. Third, fix what fails, which in most clusters means paring cluster-admin bindings back to a named few, stopping privileged containers and forcing containers to run as non-root, adding network policies so namespaces do not talk freely, moving secrets out of environment variables into mounted files, and disabling service account token auto-mount where it is not needed. Fourth, let the scheduled scans collect the passing results as signed, timestamped evidence, so you build a history over the observation window rather than a single snapshot. Fifth, hand the evidence package to an independent auditor. The audit itself is a separate engagement you contract with a CPA firm; Screenata produces the evidence, it does not issue the report.

Can a Kubernetes cluster be HIPAA compliant?

A cluster can be operated in a compliant way, but no software is HIPAA compliant on its own, and there is no vendor BAA for Kubernetes itself because you run it. If the cluster sits on a managed service, the cloud provider's BAA covers the infrastructure underneath, not your cluster configuration or your workloads. What makes the difference is encryption of data at rest and in transit, RBAC that follows least privilege, isolation between workloads, audit logging on the API server, and evidence that all of it actually held over time rather than on the one day you looked.

Do auditors accept evidence Screenata collects from Kubernetes?

Yes. Every finding is exported as a signed, timestamped artifact, a SHA-256 hash with an RSA or ECDSA signature and an RFC 3161 timestamp, that an auditor verifies outside Screenata with a free CLI. A person reviews and approves the evidence before it reaches the auditor. Screenata collects and signs it; it does not decide the audit result.

Connect and see

Fifteen minutes after connecting Kubernetes, you know your real posture.

Pricing

Related: AWS · Google Cloud · Azure · GitHub