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/v1y anunció la retirada deClusterPolicy, la que contiene las reglasverifyImages; según la tabla de tipos de política,ImageValidatingPolicyes estable desde la 1.18,ClusterPolicyquedó obsoleta en la 1.19 y se retirará en la 1.20 (prevista para noviembre de 2026). Este tutorial verifica firmas conImageValidatingPolicy.
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).
| Etapa | Amenaza | Control |
|---|---|---|
| Ingesta | Envenenamiento de datos (ML02, AML.T0020) | Validación de esquema y distribución antes de versionar |
| Almacenamiento | Sustitución del dataset en el bucket o del puntero .dvc | DVC con verify, Object Lock, IAM de solo lectura, revisión de *.dvc |
| Entrenamiento | Dependencia comprometida (ML06; Ultralytics, dic. 2024) | pip install --require-hashes, sin caché, id-token fuera del job que entrena |
| Artefacto | Deserialización insegura (AML.T0011.000); modelo manipulado (ML10, AML.T0018) | safetensors o skops, escaneo, firma con model-signing |
| Build y publicación | Imagen con CVE conocidas | SBOM, grype --fail-on high --only-fixed, firma y procedencia por digest |
| Admisión | Imagen sin firma o pod privilegiado | Kyverno ImageValidatingPolicy, Pod Security Admission |
| Runtime | Extracción del modelo (ML05) o inferencia de pertenencia (ML04); ejecución de código en el servidor | Cuotas 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-ownersen CODEOWNERS. - Un rol de entrenamiento que solo lee el prefijo de DVC, sin
s3:PutObjectnis3: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
subarepo:org/repo:ref:refs/heads/main(patrón en el post sobre secuestro de pipelines).signusa el token solo para Sigstore. - No hay caché de dependencias. En Ultralytics (diciembre de 2024), el atacante usó un workflow con
pull_request_targety 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
datasetymodelcaducan al día. model_signingfirma un manifiesto con el hash de cada fichero del directorio y guarda un bundle de Sigstore enmodel.sig. Como el.dvcva dentro demodel/, 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 exigereadOnlyRootFilesystem; lo añado para que un payload no pueda reescribir el código ni el modelo. default-deny-allbloquea 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.