Bezpečnosť a správa identít

Predchádzajúce kapitoly spomínali bezpečnosť na viacerých miestach: Secret v Kubernetes, minimálne oprávnenia pipeline, podpisovanie obrazov či šifrovanie premenných v Ansible. Táto kapitola tieto časti spája. Vysvetľuje, kto smie s klaudovými zdrojmi pracovať, ako sa spravujú tajomstvá, ako sa obmedzuje sieťová komunikácia a ako sa sprísňuje beh samotných kontajnerov.

Bezpečnosť nie je jeden nástroj ani posledný krok pred spustením. Je to vlastnosť celého systému, ktorá sa navrhuje, overuje a udržiava rovnako ako dostupnosť.

Oblasť Otázka Prostriedky
identita Kto sa pýta? autentifikácia
oprávnenie Čo smie urobiť? autorizácia
tajomstvo Čím sa preukazuje? heslá, tokeny, kľúče
sieť S kým smie komunikovať? segmentácia, TLS
workload Čo smie proces v uzle? securityContext, Pod Security
audit Čo sa naozaj stalo? logy, detekcia

Model zdieľanej zodpovednosti

Poskytovateľ klaudu zabezpečuje fyzické dátové centrá, hardvér a vlastnú virtualizačnú vrstvu. Zákazník zodpovedá za to, čo do klaudu vloží a ako to nastaví. Hranica sa posúva podľa modelu služby z kapitoly Klaud computing:

Vrstva IaaS PaaS SaaS
dáta a prístupy používateľov zákazník zákazník zákazník
aplikácia zákazník zákazník poskytovateľ
runtime, middleware zákazník poskytovateľ poskytovateľ
operačný systém zákazník poskytovateľ poskytovateľ
virtualizácia, hardvér, budovy poskytovateľ poskytovateľ poskytovateľ

Dáta a riadenie prístupu zostávajú vždy na strane zákazníka. Väčšina únikov z klaudu nevzniká prelomením infraštruktúry poskytovateľa, ale chybou konfigurácie: verejne čitateľným úložiskom, príliš širokým oprávnením alebo uniknutým prístupovým kľúčom.


Základné princípy

  • Najmenšie potrebné oprávnenia (least privilege) – identita dostane iba oprávnenia nutné pre svoju úlohu a iba na nevyhnutný čas.
  • Obrana do hĺbky (defense in depth) – zlyhanie jednej ochrany nesmie znamenať prístup k celému systému. Sieťové pravidlá, oprávnenia a obmedzenia kontajnera sa dopĺňajú.
  • Zero trust – poloha v sieti sama osebe nezakladá dôveru. Každá požiadavka sa autentifikuje a autorizuje, aj keď prichádza z „vnútornej“ siete.
  • Bezpečné predvolené nastavenie (secure by default) – zakázané je všetko, čo nie je výslovne povolené.
  • Oddelenie povinností – tá istá identita by nemala zmenu vytvoriť, schváliť a nasadiť do produkcie.
  • Krátkodobé poverenia – token platný hodinu spôsobí pri úniku menšiu škodu než kľúč platný roky.

Princípy sa navzájom podporujú. Ak má Pod minimálne oprávnenia, beží bez root používateľa a sieťová politika mu povoľuje iba potrebné spojenia, zneužitie zraniteľnosti v aplikácii útočníkovi otvorí len malý priestor.


Identita a riadenie prístupu (IAM)

Identity and Access Management (IAM) zahŕňa správu identít a pravidiel, ktoré určujú, čo smú robiť. Každá požiadavka prechádza dvoma krokmi:

  1. Autentifikácia overí, kto požiadavku posiela, napríklad heslom s druhým faktorom, certifikátom alebo podpísaným tokenom.
  2. Autorizácia rozhodne, či overená identita smie vykonať konkrétnu akciu nad konkrétnym zdrojom.

Ľudské a strojové identity

Typ identity Príklad Odporúčaný spôsob overenia
človek administrátor, vývojár centrálny poskytovateľ identity (SSO) a viacfaktorové overenie
aplikácia v klaude virtuálny stroj, serverless funkcia identita priradená zdroju, napríklad managed identity alebo rola inštancie
workload v Kubernetes Pod ServiceAccount, prípadne federácia na klaudovú identitu
externý systém CI pipeline federácia cez OpenID Connect a krátkodobý token

Strojových identít býva v klaude oveľa viac než ľudských a často majú širšie oprávnenia. Dlhodobé prístupové kľúče uložené v konfiguračných súboroch patria medzi najčastejšie príčiny incidentov. Kde to platforma umožňuje, nahrádza ich identita priradená priamo zdroju alebo federácia, pri ktorej si systém vymení vlastný podpísaný token za krátkodobé poverenie klaudu.

Politiky a roly

Oprávnenia sa nepriraďujú jednotlivým osobám priamo, ale cez roly alebo skupiny. Rola je pomenovaná množina oprávnení, napríklad „čítanie záloh“. Politika v AWS IAM, ktorá povoľuje iba čítanie objektov z jedného úložiska, vyzerá takto:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject", "s3:ListBucket"],
      "Resource": [
        "arn:aws:s3:::skola-zalohy",
        "arn:aws:s3:::skola-zalohy/*"
      ]
    }
  ]
}

Politika vymenúva konkrétne akcie aj zdroje. Zástupný znak "Action": "*" alebo "Resource": "*" je signálom na kontrolu, pretože oprávnenie spravidla presahuje skutočnú potrebu.

Poskytovatelia používajú odlišné názvy pre podobné koncepty:

Koncept AWS Microsoft Azure Google Cloud
identita aplikácie IAM role managed identity service account
množina oprávnení policy role definition role
priradenie oprávnení attach policy to role role assignment IAM policy binding
rozsah platnosti account, resource management group, subscription, resource group organization, folder, project
auditný záznam CloudTrail Activity Log Cloud Audit Logs

Prístup ľudí

  • Prihlásenie je centralizované cez poskytovateľa identity, takže odchod zamestnanca znamená zablokovanie jedného účtu.
  • Viacfaktorové overenie je povinné, najmä pre administrátorské role.
  • Účet root alebo globálny administrátor sa nepoužíva na bežnú prácu.
  • Zvýšené oprávnenia sa prideľujú dočasne a na žiadosť (just-in-time access).
  • Oprávnenia sa pravidelne kontrolujú a nepoužívané sa odoberajú.

Autentifikácia a autorizácia v Kubernetes

Kubernetes API server spracúva každú požiadavku v poradí autentifikácia, autorizácia a admission control. Kubernetes nemá vlastnú databázu používateľov. Ľudí overuje klientskymi certifikátmi alebo cez OIDC poskytovateľa identity. Procesy v Podoch používajú ServiceAccount, ktorý je bežným objektom API. Postupnosť týchto krokov znázorňuje obrázok 8.1.

Požiadavka na Kubernetes API prechádza autentifikáciou, autorizáciou a admission pred uložením do etcd

Obrázok 8.1: Spracovanie požiadavky na Kubernetes API

RBAC

Role-Based Access Control (RBAC) v Kubernetes používa štyri objekty:

Objekt Rozsah Úloha
Role jeden namespace zoznam povolených akcií nad zdrojmi
ClusterRole celý klaster to isté pre zdroje bez namespace alebo pre opakované použitie
RoleBinding jeden namespace priradí Role alebo ClusterRole identite v namespace
ClusterRoleBinding celý klaster priradí ClusterRole identite v celom klastri

RBAC pozná iba povoľujúce pravidlá. Čo nie je povolené, je zakázané. Pravidlo tvoria apiGroups, resources a verbs, napríklad get, list, watch, create, update, patch a delete.

Oprávnenie list nad Secretmi umožňuje prečítať ich obsah. Rovnako nebezpečné sú oprávnenia create nad Podmi, ktoré umožňujú pripojiť ľubovoľný Secret alebo ServiceAccount v namespace, a escalate, bind či impersonate, ktoré umožňujú rozšíriť vlastné oprávnenia.

ServiceAccount a token

Každý namespace obsahuje ServiceAccount default. Kubernetes do Podu štandardne pripojí krátkodobý token, ktorý kubelet priebežne obnovuje. Aplikácia, ktorá s API nekomunikuje, token nepotrebuje:

spec:
  automountServiceAccountToken: false

Pre aplikácie, ktoré s API pracujú, sa vytvára samostatný ServiceAccount s vlastnou Role. Oprávnenia sa nepridávajú účtu default, pretože ten zdedí každý Pod bez výslovného nastavenia.


Správa tajomstiev

Tajomstvo (secret) je údaj, ktorý preukazuje identitu alebo chráni dáta: heslo k databáze, API token, súkromný kľúč certifikátu či šifrovací kľúč. Správa tajomstiev pokrýva celý ich životný cyklus (obrázok 8.2):

Životný cyklus tajomstva od vytvorenia po zneplatnenie s auditom

Obrázok 8.2: Životný cyklus tajomstva

Tajomstvo nepatrí do zdrojového kódu, Git histórie, kontajnerového obrazu, logov ani premenných vypísaných v pipeline. Ak sa do repozitára dostane, nestačí ho zmazať ďalším commitom. Treba ho považovať za uniknuté, zneplatniť a vydať nové.

Kubernetes Secret

Objekt Secret, predstavený v kapitole Kubernetes, oddeľuje citlivé hodnoty od manifestu Deploymentu a umožňuje ich pripojiť ako súbor alebo premennú prostredia. Sám osebe však neposkytuje silnú ochranu:

  • hodnoty sú v API iba kódované pomocou Base64,
  • bez ďalšieho nastavenia sú v etcd uložené nešifrované,
  • každý, kto smie v namespace vytvoriť Pod, môže Secret pripojiť a prečítať,
  • Secret nemá vstavanú rotáciu ani históriu verzií.

Šifrovanie Secretov v etcd zapína konfigurácia API servera. Na klastri vytvorenom pomocou kubeadm sa súbor uloží do /etc/kubernetes/enc/encryption.yaml a cestu k nemu dostane API server parametrom --encryption-provider-config v statickom manifeste /etc/kubernetes/manifests/kube-apiserver.yaml. Adresár treba zároveň pripojiť do Podu API servera ako hostPath zväzok.

apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
  - resources:
      - secrets
    providers:
      - secretbox:
          keys:
            - name: key1
              secret: <32 náhodných bajtov v Base64>
      - identity: {}

Kľúč vygeneruje príkaz head -c 32 /dev/urandom | base64. Prvý poskytovateľ v zozname šifruje nové zápisy, identity umožňuje čítať staršie nešifrované záznamy. Existujúce Secrety sa zašifrujú až po prepísaní, napríklad príkazom kubectl get secrets --all-namespaces -o json | kubectl replace -f -. Kľúč uložený na disku control plane chráni najmä zálohy etcd. V produkcii sa preto používa poskytovateľ kms, pri ktorom kľúč zostáva v externej službe správy kľúčov.

Externé úložisko tajomstiev

Väčšie prostredia ukladajú tajomstvá do špecializovaného systému, napríklad HashiCorp Vault, OpenBao, AWS Secrets Manager, Azure Key Vault alebo Google Secret Manager. Takýto systém poskytuje:

  • šifrované uloženie a riadenie prístupu ku každému tajomstvu,
  • auditný záznam každého čítania,
  • verzie a rotáciu hodnôt,
  • dynamické tajomstvá – napríklad databázový účet vytvorený na požiadanie s obmedzenou platnosťou, ktorý systém po uplynutí sám zruší.

HashiCorp Vault je rozšírený nástroj tejto kategórie. Od roku 2023 je vydávaný pod licenciou Business Source License, preto vznikol otvorený fork OpenBao v rámci Linux Foundation. Základnú prácu si možno vyskúšať na vývojovom serveri, ktorý drží dáta iba v pamäti a nie je určený na produkciu:

vault server -dev &
export VAULT_ADDR=http://127.0.0.1:8200
vault kv put secret/web api_token=zmen-ma
vault kv get -field=api_token secret/web

Vault overuje Pody pomocou metódy kubernetes: Pod predloží token svojho ServiceAccountu a Vault podľa namespace a mena ServiceAccountu rozhodne, ktoré tajomstvá smie čítať.

Tajomstvá v Kubernetes a GitOps

Pri GitOps, opísanom v kapitole CI/CD, je požadovaný stav uložený v Git repozitári. Tajomstvá sa tam však nesmú dostať v čitateľnej podobe. Používajú sa tri hlavné prístupy:

Prístup Princíp Kde je tajomstvo uložené
Sealed Secrets controller v klastri má súkromný kľúč, do Gitu ide iba zašifrovaný SealedSecret v Gite zašifrované
SOPS súbor sa šifruje kľúčom z KMS alebo age, GitOps agent ho dešifruje pri nasadení v Gite zašifrované
External Secrets Operator v Gite je iba odkaz, operátor hodnotu načíta z externého úložiska v externom úložisku

External Secrets Operator používa CRD ExternalSecret, ktorý opisuje, odkiaľ sa má hodnota načítať a do akého Secretu ju má operátor zapísať:

apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: web-secret
  namespace: kurz
spec:
  refreshInterval: 1h
  secretStoreRef:
    name: vault-backend
    kind: SecretStore
  target:
    name: web-secret
  data:
    - secretKey: API_TOKEN
      remoteRef:
        key: web
        property: api_token

Objekt SecretStore s názvom vault-backend obsahuje adresu Vaultu a spôsob overenia. Zmenu hodnoty vo Vaulte operátor premietne do Secretu najneskôr po uplynutí refreshInterval. Aplikácia ju však uvidí až po reštarte Podu, ak hodnotu číta z premennej prostredia.


Sieťová bezpečnosť

Sieťová bezpečnosť obmedzuje, odkiaľ a kam môže prevádzka tiecť. V klaude sa uplatňuje na viacerých úrovniach:

  • Segmentácia – virtuálna sieť (VPC, VNet) sa delí na verejné a privátne podsiete. Databázy a interné služby nemajú verejnú IP adresu.
  • Firewall pravidlá – security groups alebo network security groups povoľujú iba potrebné porty a zdroje. Pravidlo 0.0.0.0/0 na porte SSH alebo databázy je chybou.
  • Šifrovanie prenosu – komunikácia mimo dôveryhodnej siete používa TLS. Certifikáty sa vydávajú a obnovujú automaticky.
  • mTLS – pri vzájomnom TLS sa certifikátom preukazuje aj klient. Service mesh, napríklad Istio alebo Linkerd, ho vie zapnúť medzi všetkými službami bez zmeny aplikácie.
  • Administrátorský prístup – namiesto otvoreného SSH sa používa bastion, VPN alebo služba typu session manager s auditom.

NetworkPolicy

V predvolenom stave smie každý Pod v Kubernetes komunikovať s každým iným Podom v klastri. NetworkPolicy toto správanie obmedzí. Vynucuje ju sieťový plugin; Calico z praktického cvičenia v kapitole Kubernetes ju podporuje, niektoré jednoduché pluginy nie.

Na Pod sa politika uplatní, ak ho vyberá podSelector. Pre vybraný Pod potom platí iba prevádzka výslovne povolená niektorou politikou. Politiky sa sčítavajú a nemôžu nič zakázať, iba povoliť.

Bežný postup začína politikou, ktorá v namespace zakáže všetku prichádzajúcu prevádzku:

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

Ďalšia politika povolí prístup k Podom web iba z Ingress controllera v namespace traefik a z Podov s označením pristup: web v rovnakom namespace:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: web-allow
  namespace: kurz
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
    - Ingress
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: traefik
        - podSelector:
            matchLabels:
              pristup: web
      ports:
        - protocol: TCP
          port: http

Dve položky v zozname from sú spojené logickým „alebo“. Ak by namespaceSelector a podSelector boli v jednej položke, platili by súčasne. Táto drobná zmena odsadenia v YAML zásadne mení význam politiky.

Analogicky možno obmedziť odchádzajúcu prevádzku typom Egress. Vtedy treba výslovne povoliť aj DNS dotazy na kube-dns v namespace kube-system, inak Pod nevie preložiť názvy služieb.


Bezpečnosť kontajnerov a Podov

Kontajner zdieľa jadro s hostiteľom, ako vysvetľuje kapitola Virtualizácia a kontajnery. Proces bežiaci ako root s rozšírenými oprávneniami jadra preto pri zraniteľnosti predstavuje väčšie riziko než proces bez oprávnení.

Bezpečný obraz

  • malý základný obraz, napríklad alpine, distroless alebo scratch, obsahuje menej balíkov so zraniteľnosťami,
  • aplikácia beží pod neprivilegovaným používateľom určeným inštrukciou USER v Dockerfile,
  • obraz sa skenuje na známe zraniteľnosti a podpisuje už v pipeline,
  • obraz sa nasadzuje podľa digestu, nie podľa pohyblivého tagu.

securityContext

securityContext nastavuje obmedzenia pre Pod alebo jednotlivý kontajner:

spec:
  automountServiceAccountToken: false
  securityContext:
    runAsNonRoot: true
    runAsUser: 101
    seccompProfile:
      type: RuntimeDefault
  containers:
    - name: web
      securityContext:
        allowPrivilegeEscalation: false
        readOnlyRootFilesystem: true
        capabilities:
          drop:
            - ALL
  • runAsNonRoot zabráni spusteniu kontajnera pod používateľom s UID 0.
  • seccompProfile: RuntimeDefault obmedzí systémové volania na bezpečnú množinu definovanú runtime.
  • allowPrivilegeEscalation: false zabráni získaniu vyšších oprávnení, napríklad cez programy s príznakom setuid.
  • readOnlyRootFilesystem sprístupní súborový systém kontajnera iba na čítanie. Adresáre, do ktorých aplikácia zapisuje, sa pripoja ako emptyDir.
  • capabilities.drop: [ALL] odoberie všetky Linux capabilities, napríklad NET_RAW alebo SYS_ADMIN.

Pod Security Standards

Kubernetes definuje tri úrovne Pod Security Standards:

Úroveň Význam
privileged bez obmedzení, iba pre systémové komponenty
baseline zakazuje známe eskalácie, napríklad privileged: true, hostNetwork alebo hostPath
restricted vyžaduje aj beh bez root používateľa, odobraté capabilities a seccomp profil

Vstavaný admission controller Pod Security Admission úroveň vynucuje podľa štítkov namespace. Režim enforce nevyhovujúci Pod odmietne, warn vypíše varovanie a audit zapíše udalosť do auditného logu. Nové pravidlá sa preto najprv zapínajú v režime warn a audit.

Pre zložitejšie pravidlá, napríklad „obrazy iba z registra ghcr.io/skola“, slúži ValidatingAdmissionPolicy zabudovaná v Kubernetes alebo samostatné nástroje Kyverno a OPA Gatekeeper.


Audit a detekcia

Prevencia nikdy nie je úplná. Treba vedieť zistiť, čo sa stalo, a na podozrivé správanie reagovať.

  • Auditné logy klaudu zaznamenávajú volania API poskytovateľa, napríklad vytvorenie používateľa alebo zmenu politiky.
  • Kubernetes audit log zaznamenáva požiadavky na API server. Zapína sa politikou auditu, ktorá určuje, ktoré udalosti a v akej podrobnosti sa ukladajú.
  • Detekcia za behu sleduje systémové volania v uzloch. Napríklad Falco upozorní, keď sa v kontajneri spustí shell alebo proces číta citlivé súbory.
  • Skenovanie konfigurácie priebežne hľadá verejné úložiská, otvorené porty či nepoužívané kľúče.

Auditné záznamy sa ukladajú mimo systému, ktorý zaznamenávajú, aby ich útočník nemohol vymazať. Na ich spracovanie nadväzujú postupy z časti o incidentoch v kapitole Klaudová prevádzka.


Praktické cvičenie: RBAC, NetworkPolicy a Pod Security

Praktické cvičenie používa klaster, namespace kurz, Deployment a Service web z kapitoly Kubernetes a Calico ako sieťový plugin.

1. ServiceAccount s obmedzenými oprávneniami

Vytvoríme identitu pre monitorovací nástroj, ktorý smie iba čítať Pody a ich logy:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: monitor
  namespace: kurz
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-reader
  namespace: kurz
rules:
  - apiGroups: [""]
    resources: ["pods", "pods/log"]
    verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: monitor-pod-reader
  namespace: kurz
subjects:
  - kind: ServiceAccount
    name: monitor
    namespace: kurz
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: pod-reader

Oprávnenia overíme bez prihlasovania, pomocou zosobnenia identity:

kubectl apply -f rbac.yaml
kubectl auth can-i list pods -n kurz --as=system:serviceaccount:kurz:monitor
kubectl auth can-i delete pods -n kurz --as=system:serviceaccount:kurz:monitor
kubectl auth can-i get secrets -n kurz --as=system:serviceaccount:kurz:monitor
kubectl auth can-i list pods -n default --as=system:serviceaccount:kurz:monitor

Prvý príkaz vráti yes, ostatné no. Krátkodobý token pre externý nástroj vydá príkaz kubectl create token monitor -n kurz --duration=1h.

2. Obmedzenie sieťovej komunikácie

Najprv overíme, že Service web je dostupná z ľubovoľného Podu:

kubectl run klient --rm -it --restart=Never --image=busybox:1.37 -n kurz \
  -- wget -qO- -T 3 http://web

Potom aplikujeme politiky default-deny-ingress a web-allow z časti o NetworkPolicy a zopakujeme test. Bez štítku požiadavka vyprší, so štítkom pristup=web prejde:

kubectl apply -f networkpolicy.yaml
kubectl run klient --rm -it --restart=Never --image=busybox:1.37 -n kurz \
  -- wget -qO- -T 3 http://web
kubectl run klient --rm -it --restart=Never --image=busybox:1.37 -n kurz \
  --labels=pristup=web -- wget -qO- -T 3 http://web

Ak je nasadený Ingress z kapitoly Kubernetes, mal by naďalej fungovať, pretože politika povoľuje prevádzku z namespace traefik.

3. Pod Security v režime varovania

Zapneme varovania pre úroveň restricted a pomocou serverového dry-run zistíme, ktoré bežiace Pody by pri vynútení neprešli:

kubectl label namespace kurz \
  pod-security.kubernetes.io/warn=restricted \
  pod-security.kubernetes.io/audit=restricted
kubectl label --dry-run=server --overwrite namespace kurz \
  pod-security.kubernetes.io/enforce=restricted

Pôvodný Deployment s obrazom nginx:1.27-alpine beží ako root a nemá nastavený securityContext, preto Kubernetes vypíše varovania.

4. Úprava Deploymentu

Obraz nginxinc/nginx-unprivileged beží pod používateľom s UID 101 a počúva na porte 8080. Keďže Service odkazuje na pomenovaný port http, netreba ju meniť. Server zapisuje dočasné súbory do /tmp, preto ho pri súborovom systéme iba na čítanie pripojíme ako emptyDir:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
  namespace: kurz
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      automountServiceAccountToken: false
      securityContext:
        runAsNonRoot: true
        runAsUser: 101
        seccompProfile:
          type: RuntimeDefault
      containers:
        - name: nginx
          image: nginxinc/nginx-unprivileged:1.27-alpine
          ports:
            - name: http
              containerPort: 8080
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
            capabilities:
              drop:
                - ALL
          resources:
            requests:
              cpu: 50m
              memory: 32Mi
            limits:
              cpu: 200m
              memory: 128Mi
          readinessProbe:
            httpGet:
              path: /
              port: http
          volumeMounts:
            - name: tmp
              mountPath: /tmp
      volumes:
        - name: tmp
          emptyDir: {}

Po nasadení a dokončení rolloutu už dry-run nevypíše varovanie pre Pody web a úroveň restricted možno vynútiť:

kubectl apply -f web-restricted.yaml
kubectl rollout status deployment/web -n kurz
kubectl label --dry-run=server --overwrite namespace kurz \
  pod-security.kubernetes.io/enforce=restricted
kubectl label --overwrite namespace kurz \
  pod-security.kubernetes.io/enforce=restricted

Napokon overíme, že namespace odmietne privilegovaný Pod:

kubectl run test --image=nginx:1.27-alpine -n kurz

Príkaz skončí chybou violates PodSecurity "restricted:latest" so zoznamom porušených pravidiel. Z rovnakého dôvodu odteraz zlyhá aj testovací príkaz kubectl run klient z druhého kroku. Pod bez securityContext už v namespace nemožno vytvoriť.

Kontrolná úloha

Za úspešný výsledok sa považuje stav, keď kubectl auth can-i vracia očakávané odpovede, Service web je dostupná iba z povolených Podov a z Ingressu, namespace kurz má štítok enforce=restricted a Pody web bežia pod UID 101.


Kontrolný zoznam bezpečnosti

  • Ľudia sa prihlasujú cez centrálneho poskytovateľa identity s viacfaktorovým overením.
  • Administrátorské oprávnenia sa nepoužívajú na bežnú prácu a prideľujú sa dočasne.
  • Aplikácie a pipeline používajú krátkodobé poverenia namiesto statických kľúčov.
  • Roly v klaude aj v Kubernetes obsahujú iba potrebné akcie a zdroje.
  • Tajomstvá nie sú v repozitári, obraze ani logoch a majú definovanú rotáciu.
  • Secrety v etcd sú šifrované.
  • Interné služby nemajú verejnú IP adresu a firewall povoľuje iba potrebné porty.
  • Každý aplikačný namespace má predvolené zakázanie prichádzajúcej prevádzky.
  • Pody bežia bez root používateľa a namespace vynucuje aspoň úroveň baseline.
  • Auditné logy sú zapnuté, uložené mimo sledovaného systému a niekto ich vyhodnocuje.

Cvičenia

  1. Pre modelovú aplikáciu na virtuálnom stroji, v PaaS a v SaaS určite, kto zodpovedá za aktualizáciu operačného systému, zálohu dát a správu používateľov.
  2. Napíšte IAM politiku, ktorá povoľuje iba zápis nových objektov do jedného úložiska, nie ich čítanie ani mazanie.
  3. Rozšírte Role pod-reader tak, aby ServiceAccount monitor mohol čítať aj Deploymenty, a overte to príkazom kubectl auth can-i.
  4. Zistite, ktoré ServiceAccounty v klastri majú oprávnenie čítať Secrety. Pomôcka: kubectl get rolebindings,clusterrolebindings -A -o wide.
  5. Zapnite šifrovanie Secretov v etcd na testovacom klastri a overte výsledok priamym čítaním kľúča z etcd pomocou etcdctl.
  6. Doplňte NetworkPolicy typu Egress, ktorá Podom web povolí iba DNS dotazy.
  7. Vyskúšajte Vault vo vývojovom režime, uložte doň tajomstvo a vysvetlite rozdiel medzi statickým a dynamickým tajomstvom.

Zhrnutie

Bezpečnosť klaudového systému stojí na zdieľanej zodpovednosti: poskytovateľ chráni infraštruktúru, zákazník svoje dáta, identity a konfiguráciu. IAM určuje, kto smie čo robiť, a pri ľuďoch aj strojoch uprednostňuje najmenšie oprávnenia a krátkodobé poverenia. V Kubernetes túto úlohu plní RBAC so ServiceAccountmi.

Tajomstvá majú celý životný cyklus vrátane rotácie a zneplatnenia. Kubernetes Secret je iba distribučný mechanizmus, silnú ochranu dodá šifrovanie v etcd a externé úložisko, napríklad Vault. NetworkPolicy obmedzuje komunikáciu medzi Podmi, securityContext a Pod Security Standards obmedzujú, čo smie kontajner robiť v uzle. Auditné logy a detekcia za behu umožňujú zistiť, keď niektorá z ochrán zlyhá.

Odporúčaná literatúra

Previous Post Next Post

Bezpečnosť a správa identít