Tutorial Práctico: Fortificando el MLOPs – Construcción de un Pipeline de Machine Learning Seguro con DevSecOps

Actualización (15 oct 2026): Kyverno 1.17 (febrero de 2026) publicó la API policies.kyverno.io/v1 y anunció la retirada de ClusterPolicy, la que contiene las reglas verifyImages; según la tabla de tipos de política, ImageValidatingPolicy es estable desde la 1.18, ClusterPolicy quedó obsoleta en la 1.19 y se retirará en la 1.20 (prevista para noviembre de 2026). Este tutorial verifica firmas con ImageValidatingPolicy.

En febrero de 2024, JFrog encontró unos cien modelos maliciosos en Hugging Face; uno abría una shell inversa al cargarse con torch.load(). Un año después, ReversingLabs describió dos modelos que esquivaban Picklescan, el escáner de la plataforma, con un pickle roto a propósito, una técnica que bautizó como nullifAI: el payload se ejecutaba antes de que el fichero diera error.

Un pipeline de CI/CD clásico no suele inspeccionar esos ficheros. Un pipeline de ML maneja dos artefactos más: el dataset, que fija el comportamiento del modelo, y el modelo, que en formatos basados en pickle es código ejecutable. Mi regla es tratar los dos como código: nada entra en el entrenamiento sin validar y nada llega a producción sin una firma verificable. Es la línea del perfil SP 800-218A del SSDF de NIST, pensado para IA generativa, cuyas prácticas de integridad de datos y modelos también aplican aquí.

Modelo de amenazas por etapa

El envenenamiento de datos manipula el conjunto de entrenamiento (OWASP ML02). La manipulación del modelo altera el artefacto ya entrenado: pesos cambiados, una puerta trasera o un fichero sustituido (OWASP ML10). Son ataques distintos y se cortan en etapas diferentes (los AML.* son técnicas de MITRE ATLAS).

EtapaAmenazaControl
IngestaEnvenenamiento de datos (ML02, AML.T0020)Validación de esquema y distribución antes de versionar
AlmacenamientoSustitución del dataset en el bucket o del puntero .dvcDVC con verify, Object Lock, IAM de solo lectura, revisión de *.dvc
EntrenamientoDependencia comprometida (ML06; Ultralytics, dic. 2024)pip install --require-hashes, sin caché, id-token fuera del job que entrena
ArtefactoDeserialización insegura (AML.T0011.000); modelo manipulado (ML10, AML.T0018)safetensors o skops, escaneo, firma con model-signing
Build y publicaciónImagen con CVE conocidasSBOM, grype --fail-on high --only-fixed, firma y procedencia por digest
AdmisiónImagen sin firma o pod privilegiadoKyverno ImageValidatingPolicy, Pod Security Admission
RuntimeExtracción del modelo (ML05) o inferencia de pertenencia (ML04); ejecución de código en el servidorCuotas en el gateway, privacidad diferencial al entrenar, NetworkPolicy deny-all, detección

Paso 1: validar los datos antes de versionarlos

DVC solo te dirá que un dataset no ha cambiado desde que lo registraste, aunque ya llegara envenenado. Por eso la validación va primero, en la ingesta, y se repite antes de entrenar. Este script con pandera sale con error si algo no cuadra:

import sys

import pandas as pd
import pandera.pandas as pa

schema = pa.DataFrameSchema(
    {
        "age": pa.Column(int, pa.Check.in_range(18, 100)),
        "income": pa.Column(float, pa.Check.ge(0)),
        "debt_ratio": pa.Column(float, pa.Check.in_range(0, 5)),
        "label": pa.Column(int, pa.Check.isin([0, 1])),
    },
    strict=True,
    coerce=True,
)

df = schema.validate(pd.read_csv(sys.argv[1]), lazy=True)

# Rango tomado de una línea base revisada, no del propio lote
default_rate = df["label"].mean()
if not 0.02 <= default_rate <= 0.15:
    sys.exit(f"label rate {default_rate:.3f} outside reviewed baseline [0.02, 0.15]")

strict=True rechaza columnas fuera del esquema y lazy=True reúne todos los fallos en un único SchemaErrors. El script detecta roturas de esquema y desviaciones gruesas, como etiquetas invertidas en masa. Un envenenamiento dirigido de pocas muestras que no mueve las estadísticas pasa; NIST AI 100-2 describe esas variantes.

DVC: versionado que delata cambios

DVC guarda en Git un puntero (.dvc) con el hash y el tamaño del fichero, y el contenido en un remoto (aquí, S3). Estos comandos los ejecuta la identidad de ingesta, la única con permiso de escritura:

#!/usr/bin/env bash
set -euo pipefail

pip install --require-hashes -r requirements-data.lock # dvc[s3]==3.67.1

dvc init
dvc remote add -d storage s3://ml-data-example/dvc
dvc remote modify storage verify true

dvc add data/train_data.csv
dvc push

git add .dvc data/.gitignore data/train_data.csv.dvc
git commit -m "Add training dataset v1"

Con verify true, dvc pull y dvc fetch recalculan el hash de lo descargado y lo comparan con el del puntero. Dos límites: el hash es MD5, que no resiste colisiones, y quien pueda hacer commit de un .dvc nuevo redefine qué es correcto. DVC muestra qué cambió; para que cambiarlo cueste, añade:

  • Versionado y S3 Object Lock en el bucket. Protege cada versión contra borrado y sobrescritura durante la retención (en modo compliance, ni la cuenta root puede acortarla), pero no impide subir versiones nuevas.
  • Rama protegida y revisión obligatoria de los punteros con *.dvc @org/ml-data-owners en CODEOWNERS.
  • Un rol de entrenamiento que solo lee el prefijo de DVC, sin s3:PutObject ni s3:DeleteObject:
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::ml-data-example/dvc/*"
    },
    {
      "Effect": "Allow",
      "Action": "s3:ListBucket",
      "Resource": "arn:aws:s3:::ml-data-example",
      "Condition": { "StringLike": { "s3:prefix": "dvc/*" } }
    }
  ]
}

Paso 2: entrenar y guardar sin pickle

La documentación de Python advierte que deserializar un pickle malicioso puede ejecutar código arbitrario. PyTorch 2.6 pasó torch.load a weights_only=True por defecto (anuncio), y CVE-2025-32434 mostró que hasta la 2.5.1 se podía ejecutar código incluso con ese modo. Restringir un formato ejecutable reduce el riesgo; un formato que solo contiene tensores saca la ejecución de código de la ruta de carga.

Para PyTorch, guarda los pesos en safetensors y reconstruye la arquitectura desde tu código:

from pathlib import Path

import torch
from safetensors.torch import load_model, save_model


def build_model() -> torch.nn.Module:
    return torch.nn.Sequential(
        torch.nn.Linear(3, 16),
        torch.nn.ReLU(),
        torch.nn.Linear(16, 1),
    )


# Entrenamiento
model = build_model()
# ... bucle de entrenamiento ...
Path("model").mkdir(exist_ok=True)
save_model(model, "model/model.safetensors")

# Serving: arquitectura desde el código, pesos desde el fichero
served = build_model()
load_model(served, "model/model.safetensors")
served.eval()

load_model usa strict=True por defecto y falla si al fichero le sobran o le faltan claves. Para scikit-learn, skops evita pickle: skops.io.get_untrusted_types() lista los tipos del fichero que no son de confianza por defecto y skops.io.load(..., trusted=[...]) falla si aparece uno que no has revisado.

Si partes de un modelo de terceros en pickle, escanéalo con ModelScan (modelscan -p models/base/ sale con error si encuentra problemas o no puede escanear) y conviértelo a safetensors en un entorno aislado, sin credenciales ni red: convertir implica cargarlo. nullifAI muestra su límite: el escaneo es detección y se puede esquivar.

Paso 3: entrenar y firmar en jobs separados

En .github/workflows/train.yml, solo fetch-data y sign tienen id-token: write. train instala el stack de entrenamiento y ejecuta tu código sin poder pedir un token OIDC: una dependencia comprometida ahí no asume el rol de AWS ni obtiene un certificado de Sigstore a nombre de train.yml. Cada job instala solo lo suyo desde un lock con versiones exactas y hashes (requirements-data.lock, requirements.lock con pandera==0.34.1…, requirements-sign.lock con model-signing==1.1.1) generado con pip-compile --generate-hashes, y pip rechaza cualquier paquete cuyo hash no coincida (modo hash-checking). La firma usa OpenSSF model-signing en modo keyless; en la 1.1.1, sus flags usan guion bajo.

name: train-and-sign

on:
  push:
    branches: [main]
    paths:
      - "data/*.dvc"
      - "src/**"
      - "requirements*.lock"
  workflow_dispatch:

permissions:
  contents: read

jobs:
  fetch-data:
    runs-on: ubuntu-24.04
    permissions:
      contents: read
      id-token: write
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          persist-credentials: false
      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
        with:
          python-version: "3.12"
      - uses: aws-actions/configure-aws-credentials@e1253824e5c10ff9df46874f81ed3ec929e19cfd # v6.3.0
        with:
          role-to-assume: arn:aws:iam::123456789012:role/ml-train-read-only
          aws-region: eu-west-1
      - name: Pull dataset (verify=true)
        run: |
          pip install --require-hashes -r requirements-data.lock
          dvc pull
      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          name: dataset
          path: data/train_data.csv
          retention-days: 1
          if-no-files-found: error

  train:
    needs: fetch-data
    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          persist-credentials: false
      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
        with:
          python-version: "3.12"
      - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
        with:
          name: dataset
          path: data
      - name: Validate and train
        run: |
          pip install --require-hashes -r requirements.lock
          python src/validate_data.py data/train_data.csv
          python src/train.py
          cp data/train_data.csv.dvc model/
      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          name: model
          path: model/
          retention-days: 1
          if-no-files-found: error

  sign:
    needs: train
    runs-on: ubuntu-24.04
    permissions:
      contents: read
      id-token: write
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          persist-credentials: false
      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
        with:
          python-version: "3.12"
      - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
        with:
          name: model
          path: model
      - name: Sign model directory
        run: |
          pip install --require-hashes -r requirements-sign.lock
          model_signing sign sigstore model --signature model.sig --use_ambient_credentials
      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          name: signed-model
          path: |
            model/
            model.sig
          if-no-files-found: error
  • La política de confianza del rol de AWS fija el sub a repo:org/repo:ref:refs/heads/main (patrón en el post sobre secuestro de pipelines). sign usa el token solo para Sigstore.
  • No hay caché de dependencias. En Ultralytics (diciembre de 2024), el atacante usó un workflow con pull_request_target y una inyección por el nombre de rama para envenenar la caché de GitHub Actions que usaba el build de publicación (análisis de PyPI). El lock no te protege si lo regeneras mientras hay una versión maliciosa publicada.
  • Quien tenga lectura en el repositorio puede descargar los artefactos de un run; por eso dataset y model caducan al día.
  • model_signing firma un manifiesto con el hash de cada fichero del directorio y guarda un bundle de Sigstore en model.sig. Como el .dvc va dentro de model/, la firma cubre también la versión del dataset que el workflow declara haber usado.

La firma prueba qué identidad firmó y que los ficheros no han cambiado, no que el entrenamiento fuera correcto ni que los datos estuvieran limpios: si alguien compromete train, sign firmará lo que reciba. Separar los jobs limita quién obtiene tokens, no qué se firma; proteger el workflow y la rama es parte del control.

Registro de modelos: quién escribe y quién lee

Si guardas los modelos fuera de la imagen, por ejemplo en un prefijo models/ de S3, añade a sign un paso que suba model/ y model.sig a s3://ml-models-example/models/${GITHUB_SHA}/ con aws s3 cp --recursive. Ese paso asume un rol cuyo único permiso es s3:PutObject sobre arn:aws:s3:::ml-models-example/models/*; el serving usa otro con solo s3:GetObject sobre el mismo ARN, como en el JSON del paso 1. Con versionado y Object Lock, subir otra vez la misma clave crea una versión nueva y la anterior sigue protegida.

Requiere roles distintos para escribir y leer y ninguna persona con escritura en el prefijo. Su límite: dice quién pudo escribir, no qué se entrenó; eso lo prueban la firma y el .dvc que cubre, y por eso el serving verifica antes de cargar (paso 5).

Paso 4: imagen de serving con el modelo verificado

El modelo viaja dentro de la imagen, así que la firma de la imagen cubre también los pesos. La base va fijada por digest y el proceso corre sin root:

FROM python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1

WORKDIR /app
COPY requirements-serve.lock .
RUN pip install --no-cache-dir --require-hashes -r requirements-serve.lock

COPY src/serve.py .
COPY model/ ./model/

USER 10001:10001
EXPOSE 8080
CMD ["python", "serve.py"]

serve.py carga el modelo como en el paso 2. Publica la imagen como registry.example.com/app con el release.yml de Blindando la cadena de suministro, que la escanea, firma y atesta por digest con la identidad que exige la admisión. Aquí arranca cuando train-and-sign termina en main, y build-scan, que no tiene id-token, verifica el modelo antes del build. Cambia on: y el principio de ese job:

on:
  workflow_run:
    workflows: [train-and-sign]
    types: [completed]
    branches: [main]

jobs:
  build-scan:
    if: github.event.workflow_run.conclusion == 'success'
    runs-on: ubuntu-24.04
    permissions:
      contents: read
      actions: read
    outputs:
      digest: ${{ steps.build.outputs.digest }}
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          ref: ${{ github.event.workflow_run.head_sha }}
          persist-credentials: false
      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
        with:
          python-version: "3.12"
      - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
        with:
          name: signed-model
          run-id: ${{ github.event.workflow_run.id }}
          github-token: ${{ github.token }}
      - name: Verify model signature
        env:
          SIGNER: https://github.com/org/repo/.github/workflows/train.yml@refs/heads/main
        run: |
          pip install --require-hashes -r requirements-sign.lock
          model_signing verify sigstore model --signature model.sig \
            --identity "$SIGNER" \
            --identity_provider https://token.actions.githubusercontent.com
      # From here on, the existing build-scan steps: tool install, login, build, SBOM and gate

El orden es el control: si la firma no es de train.yml en main, model_signing verify falla y no hay build. Un workflow disparado por workflow_run tiene acceso a secretos aunque el que lo disparó no lo tuviera; aquí el disparador solo corre en main y la verificación rechaza un artefacto manipulado. Leer artefactos de otro run exige github-token y actions: read.

La SBOM de ese workflow lista el fichero del modelo gracias al catalogador de safetensors de Syft, activo por defecto en imágenes, pero no dice con qué datos se entrenó. El gate es --fail-on high --only-fixed. La política completa está en Blindando la cadena de suministro: sin firma y atestación de ese release.yml, la admisión rechaza el Pod.

Paso 5: serving en Kubernetes con mínimo privilegio

Este servidor de inferencia no necesita hablar con la API de Kubernetes ni abrir conexiones salientes:

apiVersion: v1
kind: Namespace
metadata:
  name: ml-serving
  labels:
    pod-security.kubernetes.io/enforce: restricted
    pod-security.kubernetes.io/enforce-version: v1.37
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: credit-model
  namespace: ml-serving
automountServiceAccountToken: false
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: credit-model
  namespace: ml-serving
spec:
  selector:
    matchLabels:
      app: credit-model
  template:
    metadata:
      labels:
        app: credit-model
    spec:
      serviceAccountName: credit-model
      securityContext:
        runAsNonRoot: true
        runAsUser: 10001
        runAsGroup: 10001
        seccompProfile:
          type: RuntimeDefault
      containers:
        - name: server
          image: registry.example.com/app@sha256:<digest>
          ports:
            - containerPort: 8080
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
            capabilities:
              drop: ["ALL"]
          volumeMounts:
            - name: tmp
              mountPath: /tmp
      volumes:
        - name: tmp
          emptyDir: {}
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: ml-serving
spec:
  podSelector: {}
  policyTypes:
    - Ingress
    - Egress
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-gateway-to-model
  namespace: ml-serving
spec:
  podSelector:
    matchLabels:
      app: credit-model
  policyTypes:
    - Ingress
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: gateway
      ports:
        - protocol: TCP
          port: 8080
  • El namespace aplica el perfil Restricted de Pod Security Admission, fijado a la versión menor del clúster; el porqué de cada campo está en el post de defensa en Kubernetes. Valida el pod al crearlo, no lo que hace después.
  • La ServiceAccount propia, con automountServiceAccountToken: false, deja al proceso sin token para la API. Restricted no exige readOnlyRootFilesystem; lo añado para que un payload no pueda reescribir el código ni el modelo.
  • default-deny-all bloquea también la salida: una shell inversa como la del caso de JFrog no conecta. Requiere un CNI que implemente NetworkPolicy; sin él, el recurso no tiene efecto. Tampoco queda DNS; si lo necesitas, ábrelo.

Si el modelo se descarga al arrancar desde el registro del paso 3, ejecuta model_signing verify con la misma identidad en un initContainer: si falla, el servidor no arranca. Esa variante necesita salida hacia el almacén del modelo y, salvo que pases la raíz de confianza con --trust_config, hacia Sigstore: abre solo esos destinos.

Contra la extracción del modelo (OWASP ML05), NIST AI 100-2 cita limitar las consultas y detectar las sospechosas, algo que un atacante con recursos puede sortear; en la práctica, autenticación y cuotas por cliente en el gateway, delante del pod. Contra la inferencia de pertenencia (ML04), la privacidad diferencial al entrenar acota el éxito del atacante a costa de precisión; devolver solo la clase no basta, porque hay ataques que solo usan etiquetas. La detección en runtime está en el post de defensa en Kubernetes.

Fuera de alcance

Quedan fuera las entradas adversarias (OWASP ML01), el envenenamiento por alguien con acceso legítimo a la fuente y los riesgos propios de los LLM, como la inyección de prompts.

Referencias

Blog

¿Hablamos de seguridad?

Charlas, prensa o colaboraciones: escríbeme.