Segurança de Containers — Docker, Kubernetes, imagens, capabilities e network policies

Containers não são VMs. Eles compartilham o kernel do host. Um container comprometido pode impactar o host ou outros containers se as configurações de segurança não forem aplicadas corretamente.

Segurança de imagens Docker

A imagem é o ponto de partida. Uma imagem insegura contamina todos os containers derivados:

# Ruim: usa root, imagem base genérica e grande
FROM ubuntu:latest
RUN apt-get install -y python3
COPY app.py /app/app.py
CMD ["python3", "/app/app.py"]

# Melhor: imagem mínima, usuário não-root, sem pacotes desnecessários
FROM python:3.12-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser
CMD ["python3", "app.py"]

Escaneie imagens antes do deploy:

# Trivy — scanner de vulnerabilidades em imagens
trivy image python:3.12-alpine
trivy image --severity HIGH,CRITICAL minha-app:latest

Capabilities Linux — reduza ao mínimo

Containers herdam capabilities do kernel. Remova tudo e adicione só o necessário:

# docker-compose.yml
services:
  app:
    image: minha-app:latest
    cap_drop:
      - ALL
    cap_add:
      - NET_BIND_SERVICE   # só se precisar de porta < 1024
    security_opt:
      - no-new-privileges:true
    read_only: true

Nunca rode containers com --privileged em produção — isso equivale a dar acesso root ao host.

Seccomp e AppArmor

Seccomp filtra quais syscalls o container pode fazer:

# Docker já aplica um perfil seccomp padrão
# Para inspecionar o perfil atual:
docker inspect --format='{{.HostConfig.SecurityOpt}}' meu_container

# Aplicar perfil customizado restritivo:
docker run --security-opt seccomp=/path/to/perfil.json minha-app

Kubernetes — configurações de segurança

Pod Security Standards

# SecurityContext no pod
apiVersion: v1
kind: Pod
metadata:
  name: app-segura
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    fsGroup: 2000
    seccompProfile:
      type: RuntimeDefault
  containers:
  - name: app
    image: minha-app:1.2.3
    securityContext:
      allowPrivilegeEscalation: false
      readOnlyRootFilesystem: true
      capabilities:
        drop: ["ALL"]

Network Policies — segmentação de rede

Por padrão, todos os pods se comunicam entre si. Network Policies implementam o princípio do menor privilégio na camada de rede:

# Permitir apenas tráfego do frontend para o backend na porta 8080
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
  namespace: producao
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 8080

RBAC — controle de acesso

# ServiceAccount com permissões mínimas
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: app-reader
rules:
- apiGroups: [""]
  resources: ["configmaps"]
  verbs: ["get", "list"]
---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: app-reader-binding
subjects:
- kind: ServiceAccount
  name: minha-app-sa
roleRef:
  kind: Role
  name: app-reader
  apiGroup: rbac.authorization.k8s.io

Checklist de segurança

Docker:
  - Imagem base mínima (alpine, distroless)
  - Usuário não-root no Dockerfile
  - Scan de vulnerabilidades no CI/CD (Trivy, Grype)
  - Sem secrets em variáveis de ambiente — use secrets manager
  - Sem --privileged, sem montagem de /var/run/docker.sock

Kubernetes:
  - Pod Security Standards habilitado (enforce: restricted)
  - Network Policies definidas para todos os namespaces
  - RBAC com ServiceAccounts dedicadas por aplicação
  - Imagens com tag de versão fixa (nunca :latest em produção)
  - Admission controllers: OPA/Gatekeeper ou Kyverno para enforce de políticas