How to Set Up Kubernetes RBAC for OpenClaw

# k8s/namespace.yaml:
apiVersion: v1
kind: Namespace
metadata:
  name: openclaw-production
  labels:
    environment: production
    compliance: soc2

---
# Namespace resource quota (prevent resource hogging)
apiVersion: v1
kind: ResourceQuota
metadata:
  name: openclaw-quota
  namespace: openclaw-production
spec:
  hard:
    requests.cpu: "100"
    requests.memory: "200Gi"
    limits.cpu: "200"
    limits.memory: "400Gi"
    pods: "100"

---
# Network policy (deny all by default)
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: openclaw-default-deny
  namespace: openclaw-production
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
  # No rules = deny all (default deny posture)

# k8s/service-accounts.yaml:
apiVersion: v1
kind: ServiceAccount
metadata:
  name: openclaw-agent
  namespace: openclaw-production
  labels:
    component: agent

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: openclaw-router
  namespace: openclaw-production
  labels:
    component: router

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: openclaw-monitoring
  namespace: openclaw-production
  labels:
    component: monitoring

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: openclaw-backup
  namespace: openclaw-production
  labels:
    component: backup

# Verify service accounts:
kubectl get serviceaccounts -n openclaw-production

# k8s/roles.yaml:

# Role for agent pod (read config, write logs)
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: openclaw-agent
  namespace: openclaw-production
rules:
- apiGroups: [""]
  resources: ["configmaps"]
  verbs: ["get", "list", "watch"]
  resourceNames: ["openclaw-config"]  # Only this ConfigMap
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get"]
  resourceNames: ["openclaw-credentials", "api-keys"]  # Only these secrets
- apiGroups: [""]
  resources: ["persistentvolumeclaims"]
  verbs: ["get"]
  resourceNames: ["openclaw-data"]  # Only this PVC

---
# Role for router pod (read config, watch endpoints)
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: openclaw-router
  namespace: openclaw-production
rules:
- apiGroups: [""]
  resources: ["configmaps"]
  verbs: ["get", "list"]
  resourceNames: ["openclaw-router-config"]
- apiGroups: [""]
  resources: ["endpoints"]
  verbs: ["get", "list", "watch"]  # Watch agent endpoints for service discovery
- apiGroups: [""]
  resources: ["services"]
  verbs: ["get", "list"]

---
# Role for monitoring pod (read metrics, logs)
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: openclaw-monitoring
  namespace: openclaw-production
rules:
- apiGroups: [""]
  resources: ["pods", "pods/log"]
  verbs: ["get", "list"]
- apiGroups: [""]
  resources: ["events"]
  verbs: ["list", "watch"]

---
# Role for backup pod (read data volumes)
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: openclaw-backup
  namespace: openclaw-production
rules:
- apiGroups: [""]
  resources: ["persistentvolumeclaims"]
  verbs: ["get", "list"]

# k8s/role-bindings.yaml:

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: openclaw-agent-binding
  namespace: openclaw-production
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: openclaw-agent
subjects:
- kind: ServiceAccount
  name: openclaw-agent
  namespace: openclaw-production

---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: openclaw-router-binding
  namespace: openclaw-production
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: openclaw-router
subjects:
- kind: ServiceAccount
  name: openclaw-router
  namespace: openclaw-production

---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: openclaw-monitoring-binding
  namespace: openclaw-production
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: openclaw-monitoring
subjects:
- kind: ServiceAccount
  name: openclaw-monitoring
  namespace: openclaw-production

---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: openclaw-backup-binding
  namespace: openclaw-production
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: openclaw-backup
subjects:
- kind: ServiceAccount
  name: openclaw-backup
  namespace: openclaw-production

# k8s/pod-security-policy.yaml:
apiVersion: policy/v1beta1
kind: PodSecurityPolicy
metadata:
  name: openclaw-restricted
spec:
  privileged: false
  allowPrivilegeEscalation: false
  requiredDropCapabilities:
    - ALL
  allowedCapabilities: []
  volumes:
    - 'configMap'
    - 'emptyDir'
    - 'projected'
    - 'secret'
    - 'downwardAPI'
    - 'persistentVolumeClaim'
  hostNetwork: false
  hostIPC: false
  hostPID: false
  runAsUser:
    rule: 'MustRunAsNonRoot'
  seLinux:
    rule: 'MustRunAs'
    seLinuxOptions:
      level: "s0:c123,c456"
  fsGroup:
    rule: 'MustRunAs'
    fsGroupOptions:
      ranges:
        - min: 1000
          max: 65535
  readOnlyRootFilesystem: false

---
# Network policy: Agent can only talk to router
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: openclaw-agent-network
  namespace: openclaw-production
spec:
  podSelector:
    matchLabels:
      component: agent
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          component: router
  egress:
  - to:
    - podSelector:
        matchLabels:
          component: router
  - to:
    - namespaceSelector: {}
      podSelector:
        matchLabels:
          k8s-app: kube-dns
    ports:
    - protocol: UDP
      port: 53

---
# Network policy: Allow router to talk to agents
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: openclaw-router-network
  namespace: openclaw-production
spec:
  podSelector:
    matchLabels:
      component: router
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: ingress-nginx
  egress:
  - to:
    - podSelector:
        matchLabels:
          component: agent

# k8s/secrets.yaml:
apiVersion: v1
kind: Secret
metadata:
  name: openclaw-credentials
  namespace: openclaw-production
type: Opaque
data:
  # Base64 encoded (use: echo -n "value" | base64)
  database-username: b3BlbmNsYXc=
  database-password: <base64-encoded-password>
  database-host: cG9zdGdyZXMtcHJvZC5leGFtcGxlLmNvbQ==

---
# API keys secret (for external service access)
apiVersion: v1
kind: Secret
metadata:
  name: api-keys
  namespace: openclaw-production
type: Opaque
data:
  anthropic-api-key: <base64-key>
  aws-access-key: <base64-key>
  aws-secret-key: <base64-key>

---
# TLS certificate secret
apiVersion: v1
kind: Secret
metadata:
  name: openclaw-tls
  namespace: openclaw-production
type: kubernetes.io/tls
data:
  tls.crt: <base64-cert>
  tls.key: <base64-key>

# Create secrets from files securely:
kubectl create secret generic openclaw-credentials \
  --from-literal=db-password="$(cat /secure/location/password)" \
  -n openclaw-production

# Never commit secrets to Git. Use external secret management:
# - HashiCorp Vault + Sealed Secrets
# - AWS Secrets Manager + external-secrets operator
# - Azure Key Vault

# k8s/deployment-agent.yaml:
apiVersion: apps/v1
kind: Deployment
metadata:
  name: openclaw-agent
  namespace: openclaw-production
spec:
  replicas: 3
  selector:
    matchLabels:
      component: agent
  template:
    metadata:
      labels:
        component: agent
    spec:
      # Use the specific ServiceAccount we created
      serviceAccountName: openclaw-agent
      # Prevent privilege escalation
      securityContext:
        runAsNonRoot: true
        runAsUser: 1000
        fsGroup: 1000

      containers:
      - name: openclaw-agent
        image: openclaw/openclaw:2.1.0
        # Run as non-root
        securityContext:
          allowPrivilegeEscalation: false
          readOnlyRootFilesystem: true
          capabilities:
            drop:
              - ALL

        ports:
        - containerPort: 3000

        # Mount secrets as environment variables
        env:
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: openclaw-credentials
              key: database-password
        - name: API_KEY
          valueFrom:
            secretKeyRef:
              name: api-keys
              key: anthropic-api-key

        # Mount ConfigMap for configuration
        volumeMounts:
        - name: config
          mountPath: /app/config
          readOnly: true
        - name: data
          mountPath: /app/data
        - name: tmp
          mountPath: /tmp

        # Resource limits
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "1Gi"
            cpu: "1000m"

        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10

      volumes:
      - name: config
        configMap:
          name: openclaw-config
      - name: data
        persistentVolumeClaim:
          claimName: openclaw-data
      - name: tmp
        emptyDir: {}

# Test RBAC configuration:

# Check what a ServiceAccount can do:
kubectl auth can-i get secrets \
  --as=system:serviceaccount:openclaw-production:openclaw-agent \
  -n openclaw-production
# Expected: yes

kubectl auth can-i delete pods \
  --as=system:serviceaccount:openclaw-production:openclaw-agent \
  -n openclaw-production
# Expected: no

# Audit RBAC changes:
kubectl logs -f -n kube-system -l app=kube-apiserver | grep RBAC

# List all roles and bindings:
kubectl get roles -n openclaw-production
kubectl get rolebindings -n openclaw-production
kubectl get serviceaccounts -n openclaw-production

# Get detailed RBAC info for a pod:
kubectl describe pod openclaw-agent-xyz -n openclaw-production | grep ServiceAccount

# Test pod access to secrets:
kubectl exec -it openclaw-agent-xyz -n openclaw-production -- sh
# Inside pod:
ls /var/run/secrets/kubernetes.io/serviceaccount/  # Token should be here
cat /run/secrets/kubernetes.io/serviceaccount/token  # Should show JWT

# Verify network policies are working:
# Try to ping between pods that shouldn't be able to talk:
kubectl exec agent-pod -n openclaw-production -- ping router-pod
# Should timeout or fail