Skip to main content
skill CX Codex

kubernetes-security-policies — Claude Code skill

kubernetes-security-policies — a coding-agent skill that walks through Kubernetes hardening: pod security standards, network policies, RBAC. Useful when a cluster needs tightening before production.

MIT 104 installs ★ 71 updated 2026-06-29

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add NickCrew/Claude-Cortex --skill kubernetes-security-policies -a claude-code
Open on GitHub

What kubernetes-security-policies does

The skill lays the work out in phases: an audit of what's already there, then pod security standards, network segmentation, RBAC, admission control, secrets, images, runtime. Each phase comes with commands such as kubectl auth can-i --list and a rundown of mistakes to avoid — root containers, a writable root filesystem, wildcards in a Role.

Everything sits in one SKILL.md plus a references folder at skills/kubernetes-security-policies/references/, split by topic: pod-security-standards.md, network-policies.md, rbac.md, security-contexts.md, admission-control.md, secrets-management.md, image-security.md, best-practices.md. It triggers on manifests matching **/k8s/**, **/helm/**, **/*deployment*.yaml.

Some phases lean on outside tools: kube-bench or kubescape for the audit, Trivy or Snyk for image scans, Cosign for signatures, Falco for runtime. A namespace locked down by default without a DNS egress exception breaks name resolution for every pod in it, so add that rule in the same pass.

What it helps with

  • turn on Pod Security Admission for a namespace and clear the violations
  • block pod-to-pod traffic with a default-deny NetworkPolicy
  • trim a ServiceAccount down to the verbs it actually needs
  • pick OPA Gatekeeper or Kyverno for validating manifests
  • move secrets out of Git into an external store

Example prompts for the agent

  • Audit the manifests under k8s/ against the restricted Pod Security Standard and list what needs fixing.
  • Draft network policies for the payments namespace: deny everything first, then open only the flows it needs.
  • Write RBAC roles for the orders service so its ServiceAccount holds just the permissions it uses.

How to install kubernetes-security-policies

1Skills CLI (Vercel)

npx skills add NickCrew/Claude-Cortex --skill kubernetes-security-policies -a claude-code

2Manually: put the files in place

~/.claude/skills/kubernetes-security-policies/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/kubernetes-security-policies/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about kubernetes-security-policies

How do I install kubernetes-security-policies in Claude Code?

Run npx skills add NickCrew/Claude-Cortex --skill kubernetes-security-policies -a claude-code. The skill lands at ~/.claude/skills/kubernetes-security-policies/SKILL.md.

What does kubernetes-security-policies do?

It gives the agent a hardening playbook for a cluster: pod security standards, network policies, RBAC, security contexts, admission control, secrets, images.

Which tools does the skill rely on?

kube-bench or kubescape for the audit, Trivy or Snyk for image scanning, Cosign for signatures, Falco for runtime detection. Policies run through OPA Gatekeeper or Kyverno.

Source text

SKILL.md · MIT
---
name: kubernetes-security-policies
description: Kubernetes security policies, RBAC, and Pod Security Standards for hardened cluster deployments. Use when implementing cluster security, defining network policies, or enforcing security compliance in Kubernetes environments.
keywords:
  - OPA
  - RBAC
  - admission controller
  - container security
  - k8s security
  - kubernetes security
  - network policy
  - pod security
  - policy enforcement
  - security context
file_patterns:
  - '**/*deployment*.yaml'
  - '**/charts/**'
  - '**/helm/**'
  - '**/k8s/**'
  - '**/kubernetes/**'
confidence: 0.84
---

# Kubernetes Security Policies

Comprehensive guidance for implementing security policies in Kubernetes clusters, covering Pod Security Standards, Network Policies, RBAC, Security Contexts, admission control, secrets management, and runtime security for production-grade hardened deployments.

## When to Use This Skill

- Implementing Pod Security Standards (PSS/PSA) across namespaces
- Designing and enforcing Network Policies for micro-segmentation
- Configuring RBAC with least-privilege access control
- Setting Security Contexts for container hardening
- Deploying admission controllers (OPA/Gatekeeper, Kyverno)
- Managing secrets and sensitive data securely
- Implementing image security and vulnerability scanning
- Enforcing runtime security policies and threat detection
- Meeting compliance requirements (CIS, NIST, PCI-DSS, SOC2)
- Conducting security audits and hardening assessments

## Core Security Concepts

**Pod Security Standards (PSS):**
Three progressive security levels enforced via Pod Security Admission (PSA):
- **Privileged:** Unrestricted (default)
- **Baseline:** Prevents known privilege escalations
- **Restricted:** Pod hardening best practices (production recommended)

**Network Policies:**
Zero-trust micro-segmentation controlling pod-to-pod and pod-to-external traffic using label selectors and namespace isolation.

**RBAC (Role-Based Access Control):**
Least-privilege access control using ServiceAccounts, Roles, RoleBindings for namespace-scoped permissions, and ClusterRoles for cluster-wide access.

**Security Contexts:**
Container and pod-level security settings including user/group IDs, capabilities, seccomp profiles, and filesystem restrictions.

**Admission Control:**
Policy enforcement at API admission time using OPA Gatekeeper (Rego) or Kyverno (YAML) to validate, mutate, or reject resources.

**Secrets Management:**
External secret storage integration (Vault, AWS Secrets Manager, Sealed Secrets) instead of native Kubernetes secrets.

**Image Security:**
Vulnerability scanning, signature verification, digest-based immutability, and private registry authentication.

## Quick Reference

| Task | Load reference |
| --- | --- |
| Pod Security Standards (PSS/PSA) | `skills/kubernetes-security-policies/references/pod-security-standards.md` |
| Network Policies | `skills/kubernetes-security-policies/references/network-policies.md` |
| RBAC (Roles, ServiceAccounts) | `skills/kubernetes-security-policies/references/rbac.md` |
| Security Contexts (capabilities, seccomp) | `skills/kubernetes-security-policies/references/security-contexts.md` |
| Admission Control (OPA, Kyverno) | `skills/kubernetes-security-policies/references/admission-control.md` |
| Secrets Management (Vault, ESO) | `skills/kubernetes-security-policies/references/secrets-management.md` |
| Image Security (scanning, signing) | `skills/kubernetes-security-policies/references/image-security.md` |
| Best Practices & Compliance | `skills/kubernetes-security-policies/references/best-practices.md` |

## Security Implementation Workflow

### Phase 1: Baseline Assessment
1. Audit current security posture with kube-bench or kubescape
2. Identify gaps against CIS Kubernetes Benchmark
3. Document compliance requirements (PCI-DSS, NIST, SOC2)

### Phase 2: Pod Security Standards
1. Enable PSA audit mode on all namespaces
2. Identify violations using `kubectl get pods -A --show-labels`
3. Remediate workloads to meet baseline/restricted standards
4. Progressively enforce: dev (warn) → staging (baseline) → prod (restricted)

### Phase 3: Network Segmentation
1. Deploy default-deny NetworkPolicy to all namespaces
2. Create explicit allow rules for required traffic flows
3. Implement database isolation policies
4. Add monitoring/observability exceptions

### Phase 4: Access Control (RBAC)
1. Audit existing RBAC with `kubectl auth can-i --list`
2. Create dedicated ServiceAccounts per application
3. Define least-privilege Roles with specific resource/verb restrictions
4. Disable `automountServiceAccountToken` by default
5. Minimize ClusterRole usage

### Phase 5: Admission Control
1. Choose policy engine: OPA Gatekeeper (Rego) or Kyverno (YAML)
2. Implement validation policies: require labels, resource limits, non-root
3. Add mutation policies: inject security contexts, sidecar containers
4. Enforce image policies: disallow latest tag, require signatures

### Phase 6: Secrets Management
1. Deploy External Secrets Operator or Vault integration
2. Migrate native Secrets to external secret stores
3. Enable encryption at rest for etcd
4. Implement secret rotation policies

### Phase 7: Image Security
1. Integrate vulnerability scanning in CI/CD (Trivy, Snyk)
2. Implement image signing with Sigstore/Cosign
3. Enforce signature verification via admission control
4. Use immutable image digests instead of tags

### Phase 8: Runtime Security
1. Deploy Falco for runtime threat detection
2. Enable Kubernetes audit logging
3. Configure alerts for security events
4. Implement intrusion detection policies

## Common Mistakes

**Pod Security:**
- Running containers as root (always set `runAsNonRoot: true`)
- Using privileged containers (avoid unless absolutely necessary)
- Writable root filesystem (set `readOnlyRootFilesystem: true`)
- Missing resource limits (required for restricted PSS)

**Network Policies:**
- No default-deny policy (unrestricted pod-to-pod traffic)
- Overly permissive egress rules (allow all external traffic)
- Forgetting DNS egress (pods can't resolve names)
- Missing monitoring/observability exceptions

**RBAC:**
- Overly broad ClusterRole permissions (violates least privilege)
- Sharing ServiceAccounts across applications
- Using `*` verbs or resources in Roles
- Not auditing RBAC permissions regularly

**Secrets:**
- Committing secrets to Git repositories
- Using environment variables instead of mounted files
- Relying on base64 encoding as encryption
- No secret rotation policy

**Admission Control:**
- Enforcing policies without audit phase first
- Blocking kube-system namespace accidentally
- No policy testing in staging environment
- Missing exemptions for system components

**Images:**
- Using `latest` tag (not immutable, breaks reproducibility)
- No vulnerability scanning in CI/CD
- Unsigned images in production
- Large base images (use distroless or Alpine)

## Resources

- **Pod Security Standards:** https://kubernetes.io/docs/concepts/security/pod-security-standards/
- **Network Policies:** https://kubernetes.io/docs/concepts/services-networking/network-policies/
- **RBAC:** https://kubernetes.io/docs/reference/access-authn-authz/rbac/
- **OPA Gatekeeper:** https://open-policy-agent.github.io/gatekeeper/
- **Kyverno:** https://kyverno.io/docs/
- **External Secrets Operator:** https://external-secrets.io/
- **Falco Runtime Security:** https://falco.org/docs/
- **CIS Benchmarks:** https://www.cisecurity.org/benchmark/kubernetes
- **NSA/CISA Hardening Guide:** https://media.defense.gov/2022/Aug/29/2003066362/-1/-1/0/CTR_KUBERNETES_HARDENING_GUIDANCE_1.2_20220829.PDF

© NickCrew · MIT · NickCrew/Claude-Cortex

Similar skills

All skills for DevOps and infrastructure →

From the same set21

The whole set →
event-driven-architecture The event-driven-architecture skill guides event-driven system design with event sourcing, CQRS, sagas, and message brokers. Use it for microservices and distributed transactions. CX Codex +1 118installs dashboard-designer The dashboard-designer Claude Code skill plans dashboard KPIs, layout, and visual hierarchy. It activates for requests about monitoring dashboards or choosing a BI tool. CX Codex +1 109installs terraform-best-practices terraform-best-practices adds enterprise Terraform guidelines covering module layout, secure remote state, workspace isolation, and CI/CD security scanning. CX Codex +1 109installs mermaid-diagramming mermaid-diagramming gets the agent to write Mermaid diagrams for docs: flowcharts, sequence and ER diagrams, state machines, Gantt charts and architecture views. CX Codex +1 105installs user-journey-mapping The user-journey-mapping Claude Code skill lays out user journeys with stages, touchpoints, emotions, and friction points. It activates for experience mapping or conversion-flow analysis. CX Codex +1 102installs tutorial-design tutorial-design guides you through writing hands-on tutorials, workshops, and coding guides with explicit checkpoints and troubleshooting sections. CX Codex +1 102installs requirements-discovery The requirements-discovery Claude Code skill gathers requirements, sets project boundaries, and structures PRDs. It activates for feature discovery, stakeholder interviews, or specification reviews. CX Codex +1 101installs api-gateway-patterns api-gateway-patterns — a skill for API gateway design in microservices: routing, authentication, rate limiting, and request composition. CX Codex +1 101installs

Project sponsors

Companies that keep this analytics open