Kubernetes Security — Bezpečnosť klastrov

Kubernetes je mocný orchestračný nástroj, ale s veľkou mocou prichádza aj veľká zodpovednosť za bezpečnosť. Nesprávne nakonfigurovaný klaster môže byť vstupnou bránou pre útočníkov. V tomto článku si prejdeme kľúčové oblasti zabezpečenia — od RBAC cez Network Policies až po runtime ochranu.

---

RBAC — Role-Based Access Control

RBAC je základný mechanizmus autorizácie v Kubernetes. Princíp najmenších oprávnení (least privilege) by mal byť základom každej konfigurácie.

Best Practices

• Nikdy nepoužívajte cluster-admin pre bežných používateľov — vytvorte špecifické role
• Používajte Role namiesto ClusterRole kde je to možné — obmedzte scope na namespace
• Auditujte RBAC pravidelne — odstraňujte nepotrebné binding-y

Príklad: Readonly role pre namespace

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: production
  name: pod-reader
rules:
  - apiGroups: [""]
    resources: ["pods", "pods/log"]
    verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  namespace: production
  name: read-pods
subjects:
  - kind: User
    name: developer@company.com
    apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Príklad: Deployment manager role

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

---

Network Policies

Štandardne v Kubernetes môže každý pod komunikovať s každým iným podom. Network Policies umožňujú definovať, ktoré pody spolu môžu komunikovať.

Default Deny — základ bezpečnosti

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

Táto politika zablokuje všetku komunikáciu v namespace. Potom explicitne povolíte len to, čo je potrebné:

Povolenie komunikácie frontend → 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

Povolenie egress len na DNS a externé API

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-egress
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
    - Egress
  egress:
    - to:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: kube-system
      ports:
        - protocol: UDP
          port: 53
    - to:
        - ipBlock:
            cidr: 10.0.0.0/8
      ports:
        - protocol: TCP
          port: 5432

---

Pod Security Standards

Od Kubernetes 1.25 sú Pod Security Standards (PSS) natívnym spôsobom vynucovania bezpečnostných politík. Nahrádzajú zastaraný PodSecurityPolicy.

Tri úrovne:

• Privileged — bez obmedzení
• Baseline — zabraňuje známym eskaláciám privilégií
• Restricted — najprísnejšia úroveň, vyžaduje non-root, read-only filesystem atď.

Aplikovanie na namespace

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

Bezpečný pod podľa restricted štandardu

apiVersion: v1
kind: Pod
metadata:
  name: secure-app
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    fsGroup: 1000
    seccompProfile:
      type: RuntimeDefault
  containers:
    - name: app
      image: myapp:1.0@sha256:abc123...
      securityContext:
        allowPrivilegeEscalation: false
        readOnlyRootFilesystem: true
        capabilities:
          drop: ["ALL"]
      resources:
        limits:
          memory: "256Mi"
          cpu: "500m"
        requests:
          memory: "128Mi"
          cpu: "250m"

---

Runtime Security s Falco

Falco je open-source runtime security nástroj od Sysdig. Monitoruje systémové volania (syscalls) a deteguje podozrivé správanie v reálnom čase.

Čo Falco deteguje:

• Spustenie shellu v kontajneri
• Čítanie citlivých súborov (/etc/shadow, /etc/passwd)
• Neočakávané sieťové pripojenia
• Zmeny v binárkach systému
• Eskalácia privilégií

Inštalácia cez Helm

helm repo add falcosecurity https://falcosecurity.github.io/charts
helm install falco falcosecurity/falco \
  --namespace falco --create-namespace \
  --set falcosidekick.enabled=true \
  --set falcosidekick.config.slack.webhookurl="https://hooks.slack.com/..."

Vlastné pravidlo — detekcia reverse shell

- rule: Reverse Shell in Container
  desc: Detects reverse shell connections from containers
  condition: >
    spawned_process and container and
    (proc.name in (bash, sh, zsh)) and
    fd.type = ipv4 and fd.direction = out
  output: >
    Reverse shell detected (user=%user.name command=%proc.cmdline
    container=%container.name image=%container.image.repository)
  priority: CRITICAL
  tags: [network, shell, mitre_execution]

---

Image Scanning a Supply Chain Security

Skenovanie obrazov s Trivy

# Skenovanie lokálneho obrazu
trivy image myapp:latest

# Skenovanie s custom severity
trivy image --severity HIGH,CRITICAL --exit-code 1 myapp:latest

# Skenovanie v CI pipeline
trivy image --format json --output results.json myapp:latest

Cosign — podpisovanie obrazov

# Vygenerovanie kľúčov
cosign generate-key-pair

# Podpísanie obrazu
cosign sign --key cosign.key myregistry.io/myapp:v1.0

# Overenie podpisu
cosign verify --key cosign.pub myregistry.io/myapp:v1.0

Vynucovanie podpísaných obrazov cez Kyverno

apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: verify-image-signature
spec:
  validationFailureAction: Enforce
  rules:
    - name: check-image-signature
      match:
        any:
          - resources:
              kinds: ["Pod"]
      verifyImages:
        - imageReferences: ["myregistry.io/*"]
          attestors:
            - entries:
                - keys:
                    publicKeys: |-
                      -----BEGIN PUBLIC KEY-----
                      MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE...
                      -----END PUBLIC KEY-----

---

Audit Logging

Kubernetes audit logy zaznamenávajú všetky API požiadavky. Sú nevyhnutné pre forenziku a compliance.

apiVersion: audit.k8s.io/v1
kind: Policy
rules:
  - level: RequestResponse
    resources:
      - group: ""
        resources: ["secrets", "configmaps"]
  - level: Metadata
    resources:
      - group: "apps"
        resources: ["deployments"]
  - level: None
    resources:
      - group: ""
        resources: ["endpoints", "services/status"]

---

Checklist bezpečnosti Kubernetes

Oblasť	Opatrenie	Priorita
RBAC	Princíp najmenších oprávnení	🔴 Kritická
Network	Default deny + explicitné pravidlá	🔴 Kritická
Pod Security	Restricted PSS na produkčných NS	🔴 Kritická
Image Security	Skenovanie + podpisovanie obrazov	🟠 Vysoká
Runtime	Falco alebo podobný nástroj	🟠 Vysoká
Audit	Zapnuté audit logy	🟠 Vysoká
Secrets	Externý secrets manager (Vault)	🟠 Vysoká
Etcd	Šifrovanie at-rest	🟡 Stredná

---

Záver

Bezpečnosť Kubernetes nie je jednorazová úloha — je to kontinuálny proces. Začnite s RBAC a Network Policies, implementujte Pod Security Standards a postupne pridávajte runtime ochranu a supply chain security. Každá vrstva pridáva ďalšiu úroveň ochrany podľa princípu defense-in-depth.