K8s Security Policies — Agent Skill by Seth Hobson

From the author

Implement Kubernetes security policies including NetworkPolicy, PodSecurityPolicy, and RBAC for production-grade security. Use when securing Kubernetes clusters, implementing network isolation, or enforcing pod security standards.

— the description by Seth Hobson

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to securing Kubernetes environments through defense-in-depth strategies. It covers essential security layers including Pod Security Standards, network segmentation via NetworkPolicies, fine-grained RBAC configurations, and policy enforcement using admission controllers like OPA Gatekeeper. It also includes best practices for service mesh security and compliance with industry frameworks like CIS and NIST.

What it does

Defines Pod Security Standards for namespace-level enforcement.
Provides templates for NetworkPolicies to manage ingress and egress traffic.
Outlines RBAC patterns for implementing least-privilege access control.
Demonstrates how to secure pods using security contexts.
Shows how to implement policy enforcement with OPA Gatekeeper.
Details service mesh security configurations using Istio.

When to use it

When hardening a new or existing Kubernetes cluster for production.
When implementing network segmentation between microservices.
When configuring RBAC to restrict user and service account permissions.
When ensuring compliance with security benchmarks like CIS Kubernetes.
When setting up admission control to enforce organizational policies.

Advantages

Promotes a defense-in-depth security posture.
Provides ready-to-use YAML patterns for common security configurations.
Helps minimize the attack surface of containerized applications.
Supports compliance efforts through standardized security controls.

Usage examples

“How do I restrict a namespace to only allow pods that meet the restricted security standard?”: The skill provides the specific namespace labels required to enforce the 'restricted' Pod Security Standard.
“Show me how to create a NetworkPolicy that denies all traffic by default.”: The skill provides a 'default-deny-all' NetworkPolicy YAML template.
“What is the best way to grant a service account read-only access to secrets?”: The skill provides a Role and RoleBinding pattern specifically for limiting secret access to a single service account.
“How can I check if a user has permission to list pods?”: The skill provides the 'kubectl auth can-i' command to verify effective permissions for users or service accounts.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/wshobson/k8s-security-policies/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip k8s-security-policies.zip -d .agents/skills

Documentation by Seth Hobson

Kubernetes Security Policies

Comprehensive guide for implementing NetworkPolicy, PodSecurityPolicy, RBAC, and Pod Security Standards in Kubernetes.

Purpose

Implement defense-in-depth security for Kubernetes clusters using network policies, pod security standards, and RBAC.

When to Use This Skill

Implement network segmentation
Configure pod security standards
Set up RBAC for least-privilege access
Create security policies for compliance
Implement admission control
Secure multi-tenant clusters

Pod Security Standards

1. Privileged (Unrestricted)

apiVersion: v1
kind: Namespace
metadata:
  name: privileged-ns
  labels:
    pod-security.kubernetes.io/enforce: privileged
    pod-security.kubernetes.io/audit: privileged
    pod-security.kubernetes.io/warn: privileged

2. Baseline (Minimally restrictive)

apiVersion: v1
kind: Namespace
metadata:
  name: baseline-ns
  labels:
    pod-security.kubernetes.io/enforce: baseline
    pod-security.kubernetes.io/audit: baseline
    pod-security.kubernetes.io/warn: baseline

3. Restricted (Most restrictive)

apiVersion: v1
kind: Namespace
metadata:
  name: restricted-ns
  labels:
    pod-security.kubernetes.io/enforce: restricted
    pod-security.kubernetes.io/audit: restricted
    pod-security.kubernetes.io/warn: restricted

Network Policies

Default Deny All

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: production
spec:
  podSelector: {}
  policyTypes:
    - Ingress
    - Egress

Allow Frontend to Backend

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
    - Ingress
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: frontend
      ports:
        - protocol: TCP
          port: 8080

Allow DNS

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns
  namespace: production
spec:
  podSelector: {}
  policyTypes:
    - Egress
  egress:
    - to:
        - namespaceSelector:
            matchLabels:
              name: kube-system
      ports:
        - protocol: UDP
          port: 53

Reference: See assets/network-policy-template.yaml

RBAC Configuration

Role (Namespace-scoped)

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-reader
  namespace: production
rules:
  - apiGroups: [""]
    resources: ["pods"]
    verbs: ["get", "watch", "list"]

ClusterRole (Cluster-wide)

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: secret-reader
rules:
  - apiGroups: [""]
    resources: ["secrets"]
    verbs: ["get", "watch", "list"]

RoleBinding

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: production
subjects:
  - kind: User
    name: jane
    apiGroup: rbac.authorization.k8s.io
  - kind: ServiceAccount
    name: default
    namespace: production
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Reference: See references/rbac-patterns.md

Pod Security Context

Restricted Pod

apiVersion: v1
kind: Pod
metadata:
  name: secure-pod
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    fsGroup: 1000
    seccompProfile:
      type: RuntimeDefault
  containers:
    - name: app
      image: myapp:1.0
      securityContext:
        allowPrivilegeEscalation: false
        readOnlyRootFilesystem: true
        capabilities:
          drop:
            - ALL

Policy Enforcement with OPA Gatekeeper

ConstraintTemplate

apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8srequiredlabels
spec:
  crd:
    spec:
      names:
        kind: K8sRequiredLabels
      validation:
        openAPIV3Schema:
          type: object
          properties:
            labels:
              type: array
              items:
                type: string
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8srequiredlabels
        violation[{"msg": msg, "details": {"missing_labels": missing}}] {
          provided := {label | input.review.object.metadata.labels[label]}
          required := {label | label := input.parameters.labels[_]}
          missing := required - provided
          count(missing) > 0
          msg := sprintf("missing required labels: %v", [missing])
        }

Constraint

apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sRequiredLabels
metadata:
  name: require-app-label
spec:
  match:
    kinds:
      - apiGroups: ["apps"]
        kinds: ["Deployment"]
  parameters:
    labels: ["app", "environment"]

Service Mesh Security (Istio)

PeerAuthentication (mTLS)

apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
  namespace: production
spec:
  mtls:
    mode: STRICT

AuthorizationPolicy

apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: allow-frontend
  namespace: production
spec:
  selector:
    matchLabels:
      app: backend
  action: ALLOW
  rules:
    - from:
        - source:
            principals: ["cluster.local/ns/production/sa/frontend"]

Best Practices

Implement Pod Security Standards at namespace level
Use Network Policies for network segmentation
Apply least-privilege RBAC for all service accounts
Enable admission control (OPA Gatekeeper/Kyverno)
Run containers as non-root
Use read-only root filesystem
Drop all capabilities unless needed
Implement resource quotas and limit ranges
Enable audit logging for security events
Regular security scanning of images

Compliance Frameworks

CIS Kubernetes Benchmark

Use RBAC authorization
Enable audit logging
Use Pod Security Standards
Configure network policies
Implement secrets encryption at rest
Enable node authentication

NIST Cybersecurity Framework

Implement defense in depth
Use network segmentation
Configure security monitoring
Implement access controls
Enable logging and monitoring

Troubleshooting

NetworkPolicy not working:

# Check if CNI supports NetworkPolicy
kubectl get nodes -o wide
kubectl describe networkpolicy <name>

RBAC permission denied:

# Check effective permissions
kubectl auth can-i list pods --as system:serviceaccount:default:my-sa
kubectl auth can-i '*' '*' --as system:serviceaccount:default:my-sa

k8s-manifest-generator - For creating secure manifests
gitops-workflow - For automated policy deployment

Files

ATTRIBUTION.mdAdded by AutoGineer1005 B
LICENSELicence file added by AutoGineer1.0 KiB
SKILL.md7.0 KiB
assets/network-policy-template.yaml3.1 KiB
references/rbac-patterns.md4.1 KiB

references/rbac-patterns.md

RBAC Patterns and Best Practices

Common RBAC Patterns

Pattern 1: Read-Only Access

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: read-only
rules:
  - apiGroups: ["", "apps", "batch"]
    resources: ["*"]
    verbs: ["get", "list", "watch"]

Pattern 2: Namespace Admin

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: namespace-admin
  namespace: production
rules:
  - apiGroups: ["", "apps", "batch", "extensions"]
    resources: ["*"]
    verbs: ["*"]

Pattern 3: Deployment Manager

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: deployment-manager
  namespace: production
rules:
  - apiGroups: ["apps"]
    resources: ["deployments"]
    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
  - apiGroups: [""]
    resources: ["pods"]
    verbs: ["get", "list", "watch"]

Pattern 4: Secret Reader (ServiceAccount)

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: secret-reader
  namespace: production
rules:
  - apiGroups: [""]
    resources: ["secrets"]
    verbs: ["get"]
    resourceNames: ["app-secrets"] # Specific secret only
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: app-secret-reader
  namespace: production
subjects:
  - kind: ServiceAccount
    name: my-app
    namespace: production
roleRef:
  kind: Role
  name: secret-reader
  apiGroup: rbac.authorization.k8s.io

Pattern 5: CI/CD Pipeline Access

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: cicd-deployer
rules:
  - apiGroups: ["apps"]
    resources: ["deployments", "replicasets"]
    verbs: ["get", "list", "create", "update", "patch"]
  - apiGroups: [""]
    resources: ["services", "configmaps"]
    verbs: ["get", "list", "create", "update", "patch"]
  - apiGroups: [""]
    resources: ["pods"]
    verbs: ["get", "list"]

ServiceAccount Best Practices

Create Dedicated ServiceAccounts

apiVersion: v1
kind: ServiceAccount
metadata:
  name: my-app
  namespace: production
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  template:
    spec:
      serviceAccountName: my-app
      automountServiceAccountToken: false # Disable if not needed

Least-Privilege ServiceAccount

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: my-app-role
  namespace: production
rules:
  - apiGroups: [""]
    resources: ["configmaps"]
    verbs: ["get"]
    resourceNames: ["my-app-config"]

Security Best Practices

Use Roles over ClusterRoles when possible
Specify resourceNames for fine-grained access
Avoid wildcard permissions (*) in production
Create dedicated ServiceAccounts for each app
Disable token auto-mounting if not needed
Regular RBAC audits to remove unused permissions
Use groups for user management
Implement namespace isolation
Monitor RBAC usage with audit logs
Document role purposes in metadata

Troubleshooting RBAC

Check User Permissions

kubectl auth can-i list pods --as [email protected]
kubectl auth can-i '*' '*' --as system:serviceaccount:default:my-app

View Effective Permissions

kubectl describe clusterrole cluster-admin
kubectl describe rolebinding -n production

Debug Access Issues

kubectl get rolebindings,clusterrolebindings --all-namespaces -o wide | grep my-user

Common RBAC Verbs

get - Read a specific resource
list - List all resources of a type
watch - Watch for resource changes
create - Create new resources
update - Update existing resources
patch - Partially update resources
delete - Delete resources
deletecollection - Delete multiple resources
* - All verbs (avoid in production)

Resource Scope

Cluster-Scoped Resources

Nodes
PersistentVolumes
ClusterRoles
ClusterRoleBindings
Namespaces

Namespace-Scoped Resources

Pods
Services
Deployments
ConfigMaps
Secrets
Roles
RoleBindings

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs a command-line tool, Needs Node.js

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Security And Hardening
Addy Osmani· Community
A comprehensive framework for building secure, hardened web applications through threat modeling and defensive coding practices.
SecurityClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository113.9k
Claude Security
AnthropicOfficial
Claude Security: scan the codebase (the whole repository or a scoped part of it), scan changes (this branch's or a pull request's diff, or one commit), or suggest patches (findings turned into targeted patch files, each verified by a panel of agents, that you apply when you choose). Use when the user asks to scan, audit or check code with Claude Security, to scan their changes with Claude Security, or to fix or patch Claude Security findings.
SecurityClaude CodeClaude appsOpenAI Codex+14 more
Link-onlyGitHub stars of the source repository46.3k
Mtls Configuration
Seth Hobson· Community
A comprehensive guide and template library for implementing mutual TLS (mTLS) to secure service-to-service communication in zero-trust environments.
SecurityClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository42.3k
Secrets Management
Seth Hobson· Community
A guide to implementing secure secrets management in CI/CD pipelines using industry-standard tools and best practices.
SecurityClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository42.3k
Jfrog Sec
GitHubOfficial
A specialized DevSecOps agent for automated security remediation using JFrog intelligence.
SecurityGitHub Copilot
MITGitHub stars of the source repository40.9k
Gws Modelarmor Create Template
Google WorkspaceOfficial
Create and configure new Google Model Armor templates for content safety.
SecurityClaude CodeClaude appsOpenAI Codex+14 more
Apache-2.0GitHub stars of the source repository32.2k

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download k8s-security-policies.zip