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: highAcț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: latestConfiguraț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-appSecuritatea 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: 5432Admission 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: keyPipeline 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:
- La build: Scanează imaginile, folosește imagini de bază minimale, semnează artefactele
- La deployment: Admission controllers aplică politicile
- La runtime: Monitorizează anomalii și amenințări
- Rețea: Zero-trust cu politici de rețea
- 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
- Pod Security Standards
- Trivy ecosystem supply chain temporarily compromised (GHSA-69fq-xp46-6x23)
- Kyverno: Validate Rules
- External Secrets Operator: HashiCorp Vault provider
- Network Policies
- Ingress NGINX Retirement: What You Need to Know
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 →