DevSecOps

Securitate containere Kubernetes: ghid DevSecOps

Nicu Constantin
--13 min lectura
#kubernetes#container security#DevSecOps#docker#cloud security

Ca să securizezi containerele pe Kubernetes, scanezi și semnezi imaginile în CI, aplici profilul restricted din Pod Security Standards pe fiecare namespace de aplicații, blochezi implicit traficul de rețea și adaugi politici de admission și detecție la runtime pentru ce trece de aceste controale. Ghidul arată fiecare strat ca manifest sau pipeline pe care îl poți adapta, cu versiunile de API curente la data scrierii.

Petru Constantin rulează Kubernetes, Terraform și GitLab CI/CD în producție din 2022, întâi ca Senior DevOps engineer, iar acum ca IT project manager și specialist AI care lucrează în continuare direct pe infrastructură. Exemplele de cod sunt scrise pe documentația Kubernetes 1.37, Kyverno 1.20, Gatekeeper 3.19+, External Secrets Operator (external-secrets.io/v1) și trivy-action v0.36.0.

Securitatea imaginilor de container

Scanarea imaginilor în CI/CD

Integrează scanarea de vulnerabilități în pipeline-ul de build:

# .github/workflows/container-security.yml
name: Container Security Pipeline
 
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
 
permissions:
  contents: read
 
jobs:
  build-and-scan:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      security-events: write # needed to upload SARIF to code scanning
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
      - name: Scan Dockerfile with Hadolint
        uses: hadolint/hadolint-action@06be81baf89a55ffd0e24b8f04a4185738dd3387 # v3.5.0
        with:
          dockerfile: Dockerfile
          failure-threshold: warning
 
      - name: Build container image
        run: docker build -t myapp:${{ github.sha }} .
 
      # Pinned to the commit of the immutable v0.36.0 release (see GHSA-69fq-xp46-6x23)
      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/trivy-action@ed142fd0673e97e23eac54620cfb913e5ce36c25 # v0.36.0
        with:
          image-ref: 'myapp:${{ github.sha }}'
          format: 'sarif'
          output: 'trivy-results.sarif'
          severity: 'CRITICAL,HIGH'
          exit-code: '1'
 
      - name: Upload Trivy results
        uses: github/codeql-action/upload-sarif@v4
        if: always()
        with:
          sarif_file: 'trivy-results.sarif'
 
      - name: Run Grype scanner
        uses: anchore/scan-action@27805bf3b4e84b4a5c980df22ed233c00390a439 # v7.4.2
        with:
          image: 'myapp:${{ github.sha }}'
          fail-build: true
          severity-cutoff: high

Acțiunile terțe din acest workflow sunt fixate intenționat pe SHA-uri complete de commit. Pe 19 martie 2026, un atacator cu credențiale furate a mutat cu force-push 76 din cele 77 de tag-uri de versiune din aquasecurity/trivy-action pe cod care fura credențiale. Advisory-ul proiectului (GHSA-69fq-xp46-6x23) le cere utilizatorilor: „Pin GitHub Actions to full, immutable commit SHA hashes, don't use mutable version tags.” Păstrează tag-ul de versiune într-un comentariu lângă fiecare SHA și lasă Dependabot sau Renovate să țină SHA-urile la zi.

Modele securizate de Dockerfile

Construiește imagini de container minimale și securizate:

# Multi-stage build for minimal attack surface
FROM node:24-alpine AS builder
 
WORKDIR /app
 
# Copy package files first for better layer caching
COPY package*.json ./
 
# Install all dependencies (the build needs devDependencies) and fail on high-severity advisories
RUN npm ci && \
    npm audit --audit-level=high
 
COPY . .
 
# Build, then drop devDependencies before copying node_modules to the runtime image
RUN npm run build && \
    npm prune --omit=dev
 
# Production stage: distroless, no shell and no package manager
FROM gcr.io/distroless/nodejs24-debian13
 
WORKDIR /app
 
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./
 
# Numeric non-root UID, matches runAsUser in the Deployment below
USER 1001
 
EXPOSE 8080
 
# The image entrypoint is "node", so CMD is only the script path.
# No HEALTHCHECK: there is no shell here, and Kubernetes uses the Pod's probes instead.
CMD ["dist/server.js"]

Semnarea și verificarea imaginilor

Implementează securitatea lanțului de aprovizionare cu cosign:

#!/bin/bash
# sign-and-verify.sh
set -euo pipefail
 
# Sign the digest, not a mutable tag
IMAGE="registry.example.com/myapp@sha256:<digest>"
 
# Key-based signing: generate the key pair once, then sign and verify
cosign generate-key-pair
cosign sign --key cosign.key "$IMAGE"
cosign verify --key cosign.pub "$IMAGE"
 
# Keyless signing (Sigstore): an OIDC login locally, the ambient OIDC token in CI
cosign sign "$IMAGE"
 
# Keyless verification pins who signed and which identity provider vouched for them
cosign verify \
  --certificate-identity=user@example.com \
  --certificate-oidc-issuer=https://accounts.google.com \
  "$IMAGE"

Configurații de securitate Kubernetes

Standarde de securitate pentru pod-uri

Aplică standarde de securitate pentru pod-uri folosind etichete de namespace:

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

Configurație securizată a pod-urilor

Acest Deployment setează toate câmpurile pe care le verifică profilul restricted (non-root, fără privilege escalation, toate capabilities eliminate, seccomp RuntimeDefault). Pe lângă ele adaugă root filesystem read-only și limite de resurse și nu montează token de ServiceAccount:

# secure-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: secure-app
  namespace: production
spec:
  replicas: 3
  selector:
    matchLabels:
      app: secure-app
  template:
    metadata:
      labels:
        app: secure-app
    spec:
      # Context de securitate non-root
      securityContext:
        runAsNonRoot: true
        runAsUser: 1001
        runAsGroup: 1001
        fsGroup: 1001
        seccompProfile:
          type: RuntimeDefault
 
      # Service account cu permisiuni minime
      serviceAccountName: secure-app-sa
      automountServiceAccountToken: false
 
      containers:
        - name: app
          image: registry.example.com/myapp:v1.0.0@sha256:abc123...
 
          # Context de securitate la nivel de container
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
            capabilities:
              drop:
                - ALL
            privileged: false
 
          # Limite de resurse (previne DoS)
          resources:
            limits:
              cpu: "500m"
              memory: "256Mi"
              ephemeral-storage: "100Mi"
            requests:
              cpu: "100m"
              memory: "128Mi"
 
          # Probe pentru verificarea sanatatii
          livenessProbe:
            httpGet:
              path: /health
              port: 8080
            initialDelaySeconds: 10
            periodSeconds: 15
 
          readinessProbe:
            httpGet:
              path: /ready
              port: 8080
            initialDelaySeconds: 5
            periodSeconds: 10
 
          # Montari de volume pentru directoare inscriptibile
          volumeMounts:
            - name: tmp
              mountPath: /tmp
            - name: cache
              mountPath: /app/.cache
 
          # Variabile de mediu din secrete
          env:
            - name: DATABASE_URL
              valueFrom:
                secretKeyRef:
                  name: app-secrets
                  key: database-url
 
      volumes:
        - name: tmp
          emptyDir:
            sizeLimit: 50Mi
        - name: cache
          emptyDir:
            sizeLimit: 100Mi
 
      # Restrictii de distributie topologica pentru HA
      topologySpreadConstraints:
        - maxSkew: 1
          topologyKey: kubernetes.io/hostname
          whenUnsatisfiable: DoNotSchedule
          labelSelector:
            matchLabels:
              app: secure-app

Securitatea rețelei

Politici de rețea

Implementează rețea zero-trust cu politici de rețea:

# network-policies.yaml
 
# Default deny all ingress and egress
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: production
spec:
  podSelector: {}
  policyTypes:
    - Ingress
    - Egress
---
# Allow specific app communication
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-app-traffic
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: api-server
  policyTypes:
    - Ingress
    - Egress
  ingress:
    # Allow from frontend pods
    - from:
        - podSelector:
            matchLabels:
              app: frontend
      ports:
        - protocol: TCP
          port: 8080
    # Allow from the namespace of your ingress or Gateway controller.
    # kubernetes.io/metadata.name is set by the control plane on every namespace.
    # Note: the community Ingress NGINX project is retired (no releases after March 2026).
    - from:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: ingress-system
      ports:
        - protocol: TCP
          port: 8080
  egress:
    # Allow to database
    - to:
        - podSelector:
            matchLabels:
              app: postgres
      ports:
        - protocol: TCP
          port: 5432
    # Allow DNS to CoreDNS in kube-system (UDP and TCP)
    - to:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: kube-system
          podSelector:
            matchLabels:
              k8s-app: kube-dns
      ports:
        - protocol: UDP
          port: 53
        - protocol: TCP
          port: 53
---
# Database network policy
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: database-policy
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: postgres
  policyTypes:
    - Ingress
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: api-server
      ports:
        - protocol: TCP
          port: 5432

Admission Controllers

Politici OPA Gatekeeper

Aplică politici de securitate cu OPA Gatekeeper:

# gatekeeper-constraints.yaml
# Rego v0 syntax: the default for the `rego` field. Rego v1 is opt-in (Gatekeeper 3.19+)
# under targets[].code[] with engine: Rego and version: "v1".
 
# Constraint Template: Require Non-Root
apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8srequirenonroot
spec:
  crd:
    spec:
      names:
        kind: K8sRequireNonRoot
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8srequirenonroot
 
        violation[{"msg": msg}] {
          container := input.review.object.spec.containers[_]
          not non_root(container)
          msg := sprintf("Container %v must set runAsNonRoot to true (pod or container level)", [container.name])
        }
 
        violation[{"msg": msg}] {
          container := input.review.object.spec.containers[_]
          container.securityContext.runAsUser == 0
          msg := sprintf("Container %v must not run as root (UID 0)", [container.name])
        }
 
        # Set on the container
        non_root(container) {
          container.securityContext.runAsNonRoot == true
        }
 
        # Inherited from the pod-level securityContext, unless the container overrides it
        non_root(container) {
          input.review.object.spec.securityContext.runAsNonRoot == true
          not container.securityContext.runAsNonRoot == false
        }
---
# Apply the constraint
apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sRequireNonRoot
metadata:
  name: require-non-root
spec:
  match:
    kinds:
      - apiGroups: [""]
        kinds: ["Pod"]
    namespaces:
      - production
      - staging
---
# Constraint Template: Require Resource Limits
apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8srequireresourcelimits
spec:
  crd:
    spec:
      names:
        kind: K8sRequireResourceLimits
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8srequireresourcelimits
 
        violation[{"msg": msg}] {
          container := input.review.object.spec.containers[_]
          not container.resources.limits.cpu
          msg := sprintf("Container %v must specify CPU limits", [container.name])
        }
 
        violation[{"msg": msg}] {
          container := input.review.object.spec.containers[_]
          not container.resources.limits.memory
          msg := sprintf("Container %v must specify memory limits", [container.name])
        }
---
# Constraint Template: Require Image Digest
apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8srequireimagedigest
spec:
  crd:
    spec:
      names:
        kind: K8sRequireImageDigest
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8srequireimagedigest
 
        violation[{"msg": msg}] {
          container := input.review.object.spec.containers[_]
          not contains(container.image, "@sha256:")
          msg := sprintf("Container %v must use image digest, not tag", [container.name])
        }

Politici Kyverno

Motor alternativ de politici cu Kyverno:

# kyverno-policies.yaml
# Kyverno 1.20: CEL-based policy types (policies.kyverno.io/v1).
 
# Require the 'team' label on Pods
apiVersion: policies.kyverno.io/v1
kind: ValidatingPolicy
metadata:
  name: require-team-label
spec:
  validationActions:
    - Deny
  matchConstraints:
    resourceRules:
      - apiGroups: ['']
        apiVersions: [v1]
        operations: [CREATE, UPDATE]
        resources: [pods]
  validations:
    - message: "label 'team' is required"
      expression: "'team' in object.metadata.?labels.orValue([])"
---
# Restrict image registries
apiVersion: policies.kyverno.io/v1
kind: ValidatingPolicy
metadata:
  name: restrict-image-registries
spec:
  validationActions:
    - Deny
  matchConstraints:
    resourceRules:
      - apiGroups: ['']
        apiVersions: [v1]
        operations: [CREATE, UPDATE]
        resources: [pods]
  validations:
    - message: "Images must be from approved registries"
      expression: >-
        object.spec.containers.all(c,
          c.image.startsWith('registry.example.com/') ||
          c.image.startsWith('gcr.io/myproject/'))

Kyverno 1.20 blochează crearea tipurilor vechi de politici, precum ClusterPolicy, și modificarea spec-ului lor, așa că politicile de mai sus folosesc ValidatingPolicy pe CEL. Ca să setezi valori implicite sigure în loc să respingi pod-ul, folosești un MutatingPolicy. Profilul restricted din Pod Security aplicat pe namespace respinge deja pod-urile care nu au aceste câmpuri.

Securitate runtime

Monitorizare runtime cu Falco

Deplasează Falco pentru detectarea amenințărilor la runtime:

# falco-rules.yaml (values for the falco Helm chart)
# The default ruleset already ships "Terminal shell in container"; these are additions.
customRules:
  rules-custom.yaml: |-
    # Detect an interactive shell spawned in a container
    - rule: Interactive Shell Spawned in Container
      desc: Detect a shell with a terminal attached spawned in a container
      condition: >
        spawned_process and
        container and
        shell_procs and
        proc.tty != 0
      output: >
        Shell spawned in container
        (user=%user.name container=%container.name shell=%proc.name
        parent=%proc.pname cmdline=%proc.cmdline container_id=%container.id
        image=%container.image.repository)
      priority: WARNING
      tags: [container, shell, mitre_execution]
 
    # Detect sensitive file access
    - rule: Sensitive File Access
      desc: Detect access to sensitive files
      condition: >
        open_read and
        container and
        (fd.name startswith /etc/shadow or
         fd.name startswith /etc/passwd or
         fd.name startswith /proc/self/environ)
      output: >
        Sensitive file accessed
        (user=%user.name file=%fd.name container=%container.name
        image=%container.image.repository)
      priority: CRITICAL
      tags: [container, filesystem, mitre_credential_access]
 
    # Detect crypto mining
    - rule: Crypto Mining Activity
      desc: Detect potential crypto mining
      condition: >
        spawned_process and
        container and
        (proc.name in (xmrig, minerd, cpuminer) or
         proc.cmdline contains "stratum+tcp" or
         proc.cmdline contains "pool.minexmr")
      output: >
        Crypto mining detected
        (user=%user.name process=%proc.name container=%container.name
        cmdline=%proc.cmdline image=%container.image.repository)
      priority: CRITICAL
      tags: [container, cryptomining, mitre_resource_hijacking]

Monitorizare de securitate cu eBPF

Deplasează Tetragon pentru securitate la nivel de kernel:

# tetragon-policy.yaml
# TracingPolicyNamespaced applies only to pods in the namespace where it is created.
# (matchNamespaces filters on Linux namespaces such as Pid or Mnt, not Kubernetes namespaces.)
apiVersion: cilium.io/v1alpha1
kind: TracingPolicyNamespaced
metadata:
  name: sensitive-file-access
  namespace: production
spec:
  kprobes:
    - call: "security_file_permission"
      syscall: false
      args:
        - index: 0
          type: "file"
        - index: 1
          type: "int"
      selectors:
        - matchArgs:
            - index: 0
              operator: "Prefix"
              values:
                - "/etc/shadow"
                - "/etc/passwd"
                - "/root/.ssh"
---
apiVersion: cilium.io/v1alpha1
kind: TracingPolicyNamespaced
metadata:
  name: network-connections
  namespace: production
spec:
  kprobes:
    - call: "tcp_connect"
      syscall: false
      args:
        - index: 0
          type: "sock"

Managementul secretelor

External Secrets Operator

Sincronizează secretele din vault-uri externe:

# external-secrets.yaml
# external-secrets.io/v1, the API version used in the current ESO provider docs
apiVersion: external-secrets.io/v1
kind: SecretStore
metadata:
  name: vault-backend
  namespace: production
spec:
  provider:
    vault:
      server: "https://vault.example.com"
      path: "secret"
      version: "v2"
      auth:
        kubernetes:
          mountPath: "kubernetes"
          role: "production-app"
          serviceAccountRef:
            name: "vault-auth"
---
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: app-secrets
  namespace: production
spec:
  refreshInterval: 1h
  secretStoreRef:
    name: vault-backend
    kind: SecretStore
  target:
    name: app-secrets
    creationPolicy: Owner
  data:
    - secretKey: database-url
      remoteRef:
        key: production/database
        property: connection_string
    - secretKey: api-key
      remoteRef:
        key: production/api
        property: key

Pipeline de scanare de securitate

Pipeline complet de securitate

#!/usr/bin/env python3
# security_pipeline.py
 
import subprocess
import json
import sys
from dataclasses import dataclass
from typing import List, Optional
 
@dataclass
class ScanResult:
    scanner: str
    passed: bool
    critical: int
    high: int
    medium: int
    findings: List[dict]
 
def run_trivy_scan(image: str) -> ScanResult:
    """Ruleaza scanare de vulnerabilitati Trivy"""
    result = subprocess.run(
        ["trivy", "image", "--format", "json", "--quiet", image],
        capture_output=True,
        text=True
    )
 
    data = json.loads(result.stdout)
 
    critical = high = medium = 0
    findings = []
 
    for result_item in data.get("Results", []):
        for vuln in result_item.get("Vulnerabilities", []):
            severity = vuln.get("Severity", "UNKNOWN")
            if severity == "CRITICAL":
                critical += 1
            elif severity == "HIGH":
                high += 1
            elif severity == "MEDIUM":
                medium += 1
 
            findings.append({
                "id": vuln.get("VulnerabilityID"),
                "severity": severity,
                "package": vuln.get("PkgName"),
                "title": vuln.get("Title")
            })
 
    passed = critical == 0 and high == 0
 
    return ScanResult(
        scanner="trivy",
        passed=passed,
        critical=critical,
        high=high,
        medium=medium,
        findings=findings
    )
 
def run_kubesec_scan(manifest_path: str) -> ScanResult:
    """Ruleaza scanare kubesec a manifestelor Kubernetes"""
    result = subprocess.run(
        ["kubesec", "scan", manifest_path],
        capture_output=True,
        text=True
    )
 
    data = json.loads(result.stdout)
 
    score = data[0].get("score", 0) if data else 0
    critical_findings = data[0].get("scoring", {}).get("critical", []) if data else []
 
    findings = [{"type": "critical", "rule": f} for f in critical_findings]
 
    return ScanResult(
        scanner="kubesec",
        passed=score >= 0 and len(critical_findings) == 0,
        critical=len(critical_findings),
        high=0,
        medium=0,
        findings=findings
    )
 
def main():
    image = sys.argv[1] if len(sys.argv) > 1 else "myapp:latest"
    manifest = sys.argv[2] if len(sys.argv) > 2 else "deployment.yaml"
 
    print(f"Rulam scanari de securitate pentru {image}")
 
    # Ruleaza scanarile
    trivy_result = run_trivy_scan(image)
    kubesec_result = run_kubesec_scan(manifest)
 
    # Raporteaza rezultatele
    all_passed = trivy_result.passed and kubesec_result.passed
 
    print(f"\nRezultate Trivy:")
    print(f"   Critice: {trivy_result.critical}")
    print(f"   Ridicate: {trivy_result.high}")
    print(f"   Status: {'TRECUT' if trivy_result.passed else 'ESUAT'}")
 
    print(f"\nRezultate Kubesec:")
    print(f"   Critice: {kubesec_result.critical}")
    print(f"   Status: {'TRECUT' if kubesec_result.passed else 'ESUAT'}")
 
    print(f"\n{'Toate verificarile de securitate au trecut!' if all_passed else 'Verificarile de securitate au esuat!'}")
 
    sys.exit(0 if all_passed else 1)
 
if __name__ == "__main__":
    main()

Sumar

Securitatea containerelor în Kubernetes necesită mai multe straturi de protecție:

  1. La build: Scanează imaginile, folosește imagini de bază minimale, semnează artefactele
  2. La deployment: Admission controllers aplică politicile
  3. La runtime: Monitorizează anomalii și amenințări
  4. Rețea: Zero-trust cu politici de rețea
  5. Secrete: Management extern cu rotație

Implementarea acestor controale ca parte a pipeline-ului DevSecOps asigură că securitatea este automatizată și consistentă în toate mediile.


Surse oficiale

Pe același subiect: Securitatea Pipeline-ului DevSecOps: Integrarea Securitatii in CI/CD, Automatizarea Testelor de Securitate API: Acoperirea OWASP API Top 10, Securitatea aplicatiilor in SDLC: Mutarea securitatii la stanga. Mai multe articole în categoria DevSecOps, iar munca de inginerie din spatele lor e pe pagina de servicii.

Ai nevoie de un sistem AI construit și pus în producție, cu obiectivele stabilite în scris și garanția de livrare? Vezi prețul și garanția unui Sprint DeviDevs →

Vrei agenți AI și automatizări pe care firma ta chiar se poate baza?

Le construim în sprinturi fixe de două săptămâni, apoi le securizăm. Programează un apel de 30 de minute ca să stabilim ce construim.

Programează un apel

Înainte de apel poți vedea ce construim, cât costă un sprint și ce garantăm, ce am construit deja sau ne poți scrie direct.

Digest săptămânal: agenți AI, automatizări și securitate

Cum construim agenți AI și automatizări cu Claude Code, plus securitate AI practică, integrări și note de platformă, în fiecare săptămână.

Fără spam. Te poți dezabona oricând.