Date:
Category:
DevOps Strategy
Kubernetes Security: A Practical Guide for AWS Teams

Written by
Dino Starcic
·
CEO

Kubernetes security is the work of protecting your cluster, the workloads in it and the cloud account around it. The work is yours, not the platform’s. On Amazon EKS, AWS runs the control plane, and you own identity, pod security, network rules, secrets, logging and incident response. A small team can cover that list, provided the controls are set up once, enforced by policy and checked continuously. Our Kubernetes and EKS operations service gives you senior engineers to do that work from a shared backlog, so security tasks get done instead of waiting behind feature work.
CloudwiseKeep Kubernetes Security MovingCloudwise provides senior AWS and DevOps engineers for day-to-day cloud operations, including continuous security monitoring and infrastructure management.Visit
TL;DR
Kubernetes ships flexible, not locked down. The operator has to turn on access control, network policies, secrets protection and audit logging.
On EKS, AWS secures the control plane. You are responsible for IAM, pod security, runtime, network, secrets, compliance and incident response.
Five controls do most of the work: least-privilege RBAC, default-deny network policies, enforced Pod Security Standards, protected secrets, and audit logs shipped off the cluster.
Security that depends on memory decays. Policy-as-code in CI and at admission keeps the settings from drifting.
A subscription with senior AWS and DevOps engineers can own this backlog for you, with typical 24-48 hour turnarounds.
Table of Contents
Why Kubernetes needs deliberate security
Who is responsible for what on EKS
Step 1: Lock down access with RBAC and cloud identity
Step 2: Keep the control plane and nodes off the open internet
Step 3: Segment traffic with network policies
Step 4: Enforce pod security
Step 5: Protect secrets
Step 6: Log and monitor what matters
Keeping it secure: policy as code
A starting checklist
Who does this work for you
What good looks like in a quarter
FAQ
Sources
Why Kubernetes needs deliberate security
Kubernetes is built to fit many scenarios, and that flexibility is part of the risk. The OWASP Kubernetes cheat sheet notes that the engineers deploying a cluster need to understand all the potential attack vectors, because the platform will not decide for them.
The OWASP Kubernetes Top Ten for 2025 lists the risks that come up most. In plain terms they are:
insecure workload configurations
overly permissive authorization
secrets management failures
no cluster-level policy enforcement
missing network segmentation
overly exposed components
misconfigured or vulnerable components
lateral movement from the cluster into the cloud account
broken authentication
inadequate logging and monitoring
Notice what the list is made of: configuration. Almost none of it needs a clever attacker. It needs a cluster where a default was left in place, a role was granted too broadly, or nobody was watching the logs.
Who is responsible for what on EKS
Most startups run Kubernetes through a managed service, and the first question is what the provider already covers. AWS’s EKS security best-practices guide draws the line clearly. AWS manages the control plane: the control-plane nodes, etcd and supporting infrastructure. You are responsible for:
IAM
pod security
runtime security
network security
multi-tenancy
detective controls
data encryption and secrets management
regulatory compliance
incident response
image security
That is most of the security surface. A managed control plane removes patching the API server from your plate. It does not decide who can create privileged pods in your namespaces.
Kubernetes’ own security concepts page lists the built-in tools you configure: TLS for control-plane traffic, optional encryption at rest, the Secret API, Pod Security Standards, network policies, admission controllers and audit logging. The rest of this guide takes them in a practical order.
Step 1: Lock down access with RBAC and cloud identity
RBAC (role-based access control) decides which users and service accounts can do what in the cluster. Most incidents start with a role that was too generous.
The Kubernetes Security Checklist says to grant rights to create, update, patch and delete workloads only when necessary. That right is more powerful than it looks, because anyone who can create a pod can often reach secrets and nodes through it.
In practice:
List every user, group and service account with cluster-admin or workload-creation rights.
Replace broad bindings with namespace-scoped roles for each team or pipeline.
Give pods their own cloud identity instead of sharing the node’s IAM role. On EKS that means IAM Roles for Service Accounts or EKS Pod Identity, so each workload gets only the AWS permissions it needs.
Review the list on a schedule. Roles accumulate quietly as people join, leave and ship quick fixes.
The usual failure here is the pipeline. A CI job with cluster-admin credentials is a single leaked token away from a full cluster compromise. Scoping it to one namespace and one set of verbs takes an hour and removes that exposure.
If you are tightening the AWS side at the same time, our AWS security checklist for startups covers the account-level basics that sit under your cluster.
Step 2: Keep the control plane and nodes off the open internet
The Kubernetes checklist recommends keeping the Kubernetes API, the kubelet API and etcd off the public internet. On EKS, review whether your API endpoint needs public access at all. If your engineers and pipelines can reach it through private networking or a restricted address range, restrict it.
Two more points deserve attention:
etcd is the cluster’s memory. The OWASP cheat sheet warns that write access to etcd is equivalent to root on the entire cluster, and that direct writes bypass API-server validation. With EKS, AWS operates etcd, which is a real advantage. If you ever run self-managed clusters, protect it first.
TLS everywhere. Kubernetes’ cloud native security guidance tells operators to use TLS for all API traffic, including node-to-control-plane traffic, to protect encryption keys, and to restrict misuse of the CertificateSigningRequests API.
Harden the nodes too. OWASP recommends current OS versions, patch management and firewall rules for hosts. Patching is the item that slips when a team is busy, which is why it belongs on a recurring backlog rather than a to-do list.
Step 3: Segment traffic with network policies
By default, any pod in a cluster can talk to any other pod. A network policy is a rule that limits which pods may send or receive traffic. If an attacker lands in one container, segmentation decides whether they can reach your database.
The Kubernetes checklist recommends ingress and egress network policies, including default-deny policies in each namespace. The pattern is simple:
Apply a default-deny policy for ingress and egress in each production namespace.
Add explicit allow rules for the flows the application needs, such as frontend to API, and API to database.
Allow DNS egress, or nothing will resolve and the first rollout will fail.
Confirm your network plugin enforces policies. A NetworkPolicy object does nothing without a CNI that supports it.
The common mistake is adding policies to one namespace as an experiment and never finishing. Partial coverage gives a false sense of safety. Roll it out namespace by namespace, test in staging, and keep the policies in Git.
Step 4: Enforce pod security
Pod Security Standards define how much a pod may do on its host: run as root, mount host paths, request privileged mode. The checklist asks for these enforced in all namespaces, memory limits set at or below requests, and Seccomp plus AppArmor or SELinux profiles on nodes that support them.
A workable baseline for application namespaces:
run containers as non-root
block privileged containers and host namespaces
drop Linux capabilities the app does not use
set a read-only root filesystem where the app allows it
set resource requests and limits so one workload cannot starve the node
Resource limits are a stability control as much as a security one. They also feed directly into spend, which is why our Kubernetes cost optimization guide pairs well with this step.
Step 5: Protect secrets
Kubernetes Secrets hold passwords, tokens and keys. By default they are base64-encoded, which is not encryption. Enable encryption at rest, as the Kubernetes security concepts page describes, and restrict who can read Secret objects through RBAC.
The DoD Kubernetes STIG, a US government hardening standard, ranks secrets handling among its highest-severity controls. It calls for secrets not to be stored as environment variables and for Secrets to be encrypted at rest in etcd. If you sell to US government or regulated customers, expect a reviewer to ask about both.

On AWS, many teams keep the source of truth for secrets in a managed secrets service and sync them into the cluster, so rotation happens in one place. Whatever you choose, keep secrets out of images, out of Git and out of plain environment variables.
Step 6: Log and monitor what matters
If you cannot see an attack, you cannot respond to one. OWASP’s K10 entry on inadequate logging and monitoring points out that some sensitive operations, such as creating client certificates and service account tokens, leave no permanent record in the cluster datastore. Audit logging is the only trail. It also recommends buffering logs on the node and sending them through an external message broker, so the trail survives and cannot be tampered with.
The OWASP cheat sheet adds the practical rules:
Turn on Kubernetes API audit logging, which is often not configured by default.
Ship logs to a secure destination outside the cluster.
Watch container process activity, network communication between services and to the outside, and authorization failures.
Treat a spike in 403 Forbidden responses as a possible sign of someone testing stolen or overly broad credentials.
Alerts should be few and meaningful. A flood of noisy alerts trains people to ignore them. Start with a short list: new cluster-admin bindings, privileged pod creation, changes to admission configuration, and unexpected exposure of services. For the wider monitoring picture on AWS, see our guide to AWS monitoring best practices.
Keeping it secure: policy as code
A one-time hardening pass starts decaying the day after. New services arrive, someone relaxes a rule to unblock a release, and the cluster drifts from what you intended. The fix is to turn rules into code that runs automatically.
The Kubernetes SIG Security governance paper describes enforcement across the whole software lifecycle:
Develop: CI gives early feedback on policy violations, including static analysis and protection of sensitive information.
Distribute: pipelines can enforce image signing and integrity.
Deploy: admission controllers limit what can be created to permitted content.
Runtime: continuous auditing checks running workloads and detects newly found vulnerabilities in running images.
The OWASP DevSecOps Guideline gives a rollout order that avoids breaking production:
Start in audit or warn mode and inventory what would be blocked.
Fix violations or record time-boxed exceptions with a named owner.
Turn on deny in new namespaces and in dev and staging first.
Enable one policy at a time before production.
Keep policies in Git, test them in CI and deploy them by GitOps.
Plan for webhook failure, with multiple replicas, a sensible failure policy and a break-glass procedure.
This is steady, unglamorous work, and it is exactly the kind that gets postponed when a product deadline looms. It is also where a dedicated owner pays off.
A starting checklist
Use this as a first pass on any EKS cluster:
Area | What to check |
|---|---|
Access | No broad cluster-admin bindings; workload-creation rights limited; pods use their own AWS identity |
Control plane | API endpoint restricted; TLS everywhere; hosts patched |
Network | Default-deny ingress and egress in each production namespace; CNI enforces policies |
Pods | Pod Security Standards enforced; non-root; limits set |
Secrets | Encryption at rest on; none in env vars, images or Git |
Logging | API audit logs on and shipped off-cluster; alerts on privileged pods and new admin bindings |
Process | Policies in Git, tested in CI, enforced at admission |
If you cannot answer one of these rows with confidence, that row is your first backlog item.
Who does this work for you
The list above is not long, but it is continuous. Every new service, every new engineer and every Kubernetes upgrade touches it. A startup rarely has an engineer whose job is to keep it current, and hiring a full in-house DevOps team for that is a large commitment.
Cloudwise is a subscription service that puts senior AWS and DevOps engineers on your day-to-day cloud operations. Our services include Kubernetes and container platforms, security and reliability, and monitoring and observability, which map directly onto the steps above. You submit tasks to a shared backlog, such as “scope the CI role to one namespace” or “roll out default-deny policies in production”, prioritize them yourself, and get typical turnarounds of 24 to 48 hours. There is no hourly billing and no long-term contract, and you can cancel anytime without hidden costs.

The Simplest Subscription is $7,499 per month, with details on our pricing page. You can also browse our full list of AWS and DevOps services, or see how we handle security and reliability for production workloads.
What good looks like in a quarter
Security is easier to commit to when you can see the finish line. A realistic first quarter for a team running EKS:
Weeks 1 to 2: inventory access and exposure. Find admin bindings, public endpoints and secrets in plain text.
Weeks 3 to 6: tighten RBAC, move pods to their own cloud identity, restrict the API endpoint and turn on audit logging with off-cluster shipping.
Weeks 7 to 10: roll out default-deny network policies and Pod Security Standards in warn mode, then enforce them namespace by namespace.
Weeks 11 to 13: move policies into Git and CI, add admission enforcement and set up the short alert list.
After that, the work becomes maintenance: reviewing access, patching, handling upgrades and responding to alerts. That steady rhythm suits a backlog model, because each item is small, specific and easy to hand off. If you run workloads with compliance obligations, such as patient data, the same controls feed your audit evidence. Our guide to HIPAA compliance on AWS explains what you own there.
Sources
Recommended
Questions Answered
Frequently asked questions
Clear answers to common questions about our AWS & DevOps subscription and how it works.