Dos personas pueden compartir el mismo devenv.lock, obtener las mismas herramientas y aprobar los mismos tests, y aun así ejecutar binarios diferentes en producción. El problema aparece al cruzar una frontera que el entorno de desarrollo no controla: quién construye el artefacto, con qué entradas, dónde se almacena y qué identidad termina desplegada.
En el artículo sobre Nix y devenv vimos cómo reducir diferencias entre máquinas de desarrollo. Aquí continuamos desde ese punto. No vamos a volver a explicar cómo instalar Nix ni a declarar servicios locales: el objetivo es conectar código versionado, builds, CI, distribución y operación sin atribuirles garantías que no poseen.
La tesis es concreta: un pipeline fiable no reconstruye el mismo commit en cada etapa esperando el mismo resultado; construye, identifica, comprueba y promueve un artefacto, mientras mantiene explícito lo que debe resolverse en tiempo de ejecución. Esto mejora trazabilidad y capacidad de recuperación. No demuestra, por sí solo, reproducibilidad binaria.
Cuatro objetos distintos que suelen llamarse “entorno”
| Objeto | Qué representa | Qué no contiene necesariamente |
|---|---|---|
| Entorno de desarrollo | Herramientas, shells, servicios locales y comandos para contribuir | Configuración y datos de producción |
| Entorno de build | Entradas y condiciones visibles durante la compilación | Todos los efectos no deterministas del compilador o scripts |
| Artefacto | Resultado que se distribuye: derivación Nix, binario o imagen OCI | Secretos, base de datos, certificados en uso |
| Despliegue | Selección del artefacto, servicios, red y políticas de ejecución | Garantía de que el estado real siempre coincida con la declaración |
El matiz determina qué se puede afirmar. Un build con entradas fijadas resuelve referencias previsiblemente; un build reproducible ha sido reconstruido de forma independiente y ha producido bytes idénticos en las condiciones evaluadas. El proyecto Reproducible Builds de NixOS documenta por qué el sandbox y las derivaciones no eliminan automáticamente timestamps, orden no determinista de archivos ni diferencias introducidas por herramientas.
El contrato empieza en el commit y sus locks
Para un servicio Rust pequeño vamos a utilizar un ejemplo continuo: una API HTTP que expone /health en el puerto interno 8080. Su código vive en api/; el repositorio fija entradas Nix mediante devenv.lock y dependencias Rust mediante Cargo.lock.
service-repository/
├── devenv.nix
├── devenv.yaml
├── devenv.lock
├── api/
│ ├── Cargo.toml
│ ├── Cargo.lock
│ └── src/main.rs
└── .github/workflows/ci.yml
Este árbol describe el proyecto de ejemplo, no archivos creados en el repositorio del blog. No se han generado Cargo.lock, devenv.lock ni imágenes OCI para este artículo. Los locks se obtendrían usando las herramientas reales y quedarían versionados con el código. Actualizarlos sería una decisión de mantenimiento revisable, no una acción automática al desplegar.
Para que el escenario tenga una aplicación concreta, el crate utiliza una ruta HTTP mínima. Cargo.toml declara requisitos, no sustituye al lockfile generado por Cargo:
# api/Cargo.toml — ejemplo mínimo, no ejecutado aquí
[package]
name = "edge-api"
version = "0.1.0"
edition = "2024"
[dependencies]
axum = "0.8"
tokio = { version = "1", features = ["macros", "rt-multi-thread", "net"] }
// api/src/main.rs — API demostrativa, no incluye autenticación ni límites de tráfico
use axum::{routing::get, Router};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let app = Router::new().route("/health", get(|| async { "ok" }));
let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await?;
axum::serve(listener, app).await?;
Ok(())
}
Esta API solo sirve para examinar el pipeline. No pretende ser una aplicación de producción ni establece que los checks de integración hayan sido probados. En el proyecto real, cargo generate-lockfile resuelve las dependencias y genera api/Cargo.lock; después se confirma el archivo. La siguiente compilación usa la resolución congelada con cargo test --locked. El servidor no se expone aquí; el puerto 8080 es un ejemplo de escucha dentro del contenedor.
devenv.yaml describe los inputs que luego quedan resueltos en devenv.lock. Cargo.lock registra la resolución de dependencias de Cargo. flake.lock, cuando se usa Nix mediante flakes, es un mecanismo relacionado pero no equivale al devenv.lock de un proyecto convencional. El manual de entradas de devenv y el modelo de flakes de Nix documentan ambos casos.
Un commit y dos lockfiles siguen sin identificar todos los elementos relevantes: el system de Nix, el ejecutable de devenv usado por CI, la configuración del sandbox, las credenciales de cachés y el acceso a servicios externos pueden cambiar. En Nix una derivación especifica, entre otras cosas, el sistema objetivo. Por eso construir para x86_64-linux y para aarch64-linux implica resultados específicos de cada arquitectura, incluso si proceden de las mismas fuentes. Véase el modelo de derivaciones.
Convertir una herramienta de desarrollo en un resultado instalable
El primer paso que no hacía falta para el shell local es definir una salida de build. devenv expone outputs; devenv build evalúa y construye esas salidas y, desde devenv 2.0, informa sus rutas en formato JSON. La documentación oficial de outputs muestra la integración con Rust mediante crate2nix.
Como fragmento de configuración para el servicio Rust:
# devenv.nix — fragmento para un proyecto Rust con api/Cargo.lock
{ config, ... }:
{
languages.rust.enable = true;
outputs.api = config.languages.rust.import ./api {};
# Este test pertenece al proyecto de ejemplo, no al blog.
enterTest = ''
cd api
cargo test --locked
'';
}
El fragmento supone que api/ es un crate Rust válido, tiene Cargo.lock versionado y que la versión de devenv utilizada implementa el importador documentado. Esta combinación no se ha ejecutado aquí. No equivale a entregar un repositorio de aplicación listo para producción.
El comportamiento relevante se puede inspeccionar con:
# En el repositorio de ejemplo, después de generar y confirmar los locks:
devenv test
# Construye la salida declarada y devuelve su identidad en JSON:
devenv build outputs.api
No se debe copiar un /nix/store/... inventado de un tutorial. En un proyecto real, el pipeline leerá el objeto JSON que devuelva devenv build, extraerá el store path de outputs.api y conservará esa identidad en sus metadatos de release. El path de la derivación no certifica que una compilación independiente produzca exactamente los mismos bytes; sí sirve para identificar un objeto concreto del store que puede distribuirse.
El cargo test --locked impide que Cargo modifique la resolución durante esa ejecución, pero sigue siendo necesario diseñar tests de comportamiento, compatibilidad y seguridad. La aprobación del build por sí sola no prueba que el servicio esté listo para recibir tráfico.
CI: usar la declaración sin dejar flotando el resto
Una CI seria debería responder seis preguntas antes de publicar cualquier artefacto: ¿qué commit se construyó?, ¿qué locks se usaron?, ¿qué sistema ejecutó el build?, ¿qué checks pasaron?, ¿qué artefacto exacto se produjo? y ¿dónde está la prueba de procedencia?
GitHub Actions puede instalar Nix, ejecutar devenv test y devenv build. La integración de devenv con Actions documenta esa secuencia. Para un pipeline real no es suficiente copiar el ejemplo tal cual: el propio workflow, sus acciones y la instalación del CLI deben quedar controlados.
Este bloque enseña solo los pasos internos de un job que ya haya instalado una versión revisada de Nix y devenv y tenga los permisos adecuados:
# Fragmento de steps, no workflow completo listo para pegar.
# Requiere checkout del commit correcto e instalación controlada de Nix/devenv.
- name: Probar el entorno y los tests declarados
run: devenv test
- name: Construir el resultado versionado
run: devenv build outputs.api > build-outputs.json
- name: Conservar metadatos de construcción
run: |
git rev-parse HEAD > source-commit.txt
sha256sum devenv.lock api/Cargo.lock > input-locks.sha256
sha256sum es un comando del runner Linux: en otro sistema hace falta un equivalente. Ni el YAML ni esos nombres de archivo implican que el job haya sido ejecutado. El fragmento omite intencionadamente autenticación y publicación de artefactos para no sugerir que un token de ejemplo es seguro.
Para fijar acciones externas, GitHub recomienda referenciarlas por SHA de commit. En las verificaciones del 16 de noviembre de 2026, cachix/install-nix-action publicó la serie v31 y cachix/cachix-action publicó v17; una etiqueta de versión es más legible pero no tan fuerte como un SHA revisado. La versión de devenv instalada mediante nix profile add nixpkgs#devenv también puede flotar si no se fija la referencia de origen. La lista de releases de devenv marcaba v2.4.0 como última versión etiquetada revisada, aunque el código y la documentación pueden ir por delante de las tags.
Builds en PR: pruebas sin credenciales de producción
Un PR de un fork puede modificar tanto código como workflow. Darle un token de escritura de Cachix o de un registro no es una optimización: es una frontera de seguridad mal definida. La documentación de Cachix explica los permisos de caché. Una política razonable permite a PRs no confiables leer dependencias públicas y ejecutar checks en un runner aislado, y reserva publicación/firmado para commits protegidos después de revisión.
Lo mismo vale para runners propios: los hooks de build y la configuración del daemon merecen una evaluación de privilegios; no se debe ampliar trusted-users sin comprender su impacto. Los permisos mínimos del job y la separación entre eventos (pull_request versus publicación desde rama protegida) forman parte de la reproducibilidad operativa, no son detalles cosméticos.
Cachés y distribución no son una auditoría de reproducibilidad
Una caché binaria permite obtener un objeto Nix ya construido, siempre que el cliente confíe en su origen y el objeto solicitado esté disponible. Cuando existe un cache hit, reutilizarlo evita un rebuild; eso no demuestra que otro builder obtendría los mismos bytes a partir del código fuente. Con un cache miss, la ejecución puede pasar de descargar a compilar, o fallar por red o permisos. devenv documenta estas condiciones.
La diferencia importa en incidentes. Si dos entornos consumieron el mismo contenido de caché, puedes afirmar que reutilizaron el mismo artefacto confiado; no que dos compilaciones independientes fueran deterministas. Para demostrar reproducibilidad binaria habría que repetir builds en condiciones controladas y comparar resultados, documentando discrepancias con herramientas de análisis como diffoscope. Ese experimento no forma parte de esta publicación.
Una decisión irreversible para el pipeline: promover o reconstruir
Imagina el siguiente flujo: main aprueba tests, CI construye una imagen, staging la ejecuta y producción debería recibir la misma versión. Existen dos estrategias diferentes:
| Estrategia | Ventaja | Riesgo importante |
|---|---|---|
| Reconstruir desde Git en cada ambiente | Menos dependencia de un registro de artefactos | Un tag, builder, variable o repositorio de paquetes puede cambiar entre builds |
| Promover el mismo artefacto identificado | Sabemos qué objeto se ejecuta en cada ambiente | Hay que mantener registro, permisos, limpieza, metadatos y rollback |
Para el flujo propuesto, elegiría construir una vez y promover por identidad inmutable. En una ruta OCI, la identidad de despliegue es el digest sha256 de la imagen publicada; una etiqueta como latest es un puntero mutable. El digest que se registre debe proceder de la publicación real en el registro de destino, no de un hash supuesto del Dockerfile.
Ruta OCI: devenv, registro y plataforma de ejecución
devenv puede construir contenedores OCI, pero esa funcionalidad requiere entradas adicionales como nix2container y mk-shell-bin; no basta con habilitar languages.rust. También hay una diferencia entre meter el shell completo en un contenedor y empaquetar únicamente la aplicación y las dependencias de runtime. Para producción interesa minimizar superficie y no incluir herramientas de desarrollo ni credenciales de CI.
El recorrido conceptual es el siguiente: primero se fija el commit y sus lockfiles; CI ejecuta los tests y construye outputs.api; un builder Linux genera la imagen OCI; el registro devuelve su digest; se promueve ese mismo digest a los entornos siguientes; finalmente, cada destino añade configuración, secretos, red y datos propios. No se ha dibujado ni generado un diagrama de ese flujo.
Es una secuencia explicativa, no la salida de un comando. Si el equipo decide implementar containers.prod tendrá que comprobar su API y su startupCommand en la versión fijada, diseñar la imagen de runtime, incorporar autenticación segura y registrar el digest resultante. La documentación de devenv señala además que crear imágenes Linux desde macOS exige un builder Linux, local remoto o equivalente. Un único digest para linux/amd64 no sustituye automáticamente una estrategia multi-arquitectura.
Al llegar al registro, herramientas de operación como Coolify pueden consumir directamente una imagen existente por digest sin volver a compilar desde Git. Esa es la frontera editorial entre ambos artículos: este pipeline decide qué se construye; la plataforma de despliegue decide dónde, cómo y con qué estado se ejecuta.
Ruta Nix nativa: distribuir una closure
Si el destino ejecuta Nix y tiene un modelo de activación gestionado, una opción alternativa es copiar el cierre transitivo de la salida sin reconstruirla en el servidor. La sintaxis está documentada en Nix copy:
# Fragmento ilustrativo: STORE_PATH es una ruta real obtenida del JSON del build.
nix copy --to ssh-ng://deploy.example.com "$STORE_PATH"
Aquí hay un requisito adicional que los tutoriales suelen omitir: copiar la closure no inicia el servicio. El host destino necesita su unidad systemd, perfil o configuración NixOS, permisos, política de activación y rollback. Las rutas Nix nativa y OCI son alternativas; no conviene mezclarlas en un mismo ejemplo pretendiendo que tienen las mismas operaciones de runtime.
Procedencia no es ausencia de vulnerabilidades
GitHub permite generar attestations que vinculan artefactos —incluidas imágenes por digest— con información del workflow que los creó. Sirven para responder quién construyó qué y desde qué proceso. La verificación debe comprobar que el emisor y el repositorio esperados coinciden con la política del despliegue.
Una attestation válida no prueba que el código sea seguro, que no contenga dependencias vulnerables o que el build sea bit a bit reproducible. Es una pieza de procedencia; se complementa con controles de acceso, revisión de cambios, análisis de dependencias, SBOM cuando se justifique y pruebas de comportamiento. El registro del digest sin política de verificación reduce trazabilidad, pero no convierte esa trazabilidad en una barrera de promoción por sí misma.
Configuración, secretos y datos: lo que no debe viajar dentro del artefacto
Hay cosas que deben permanecer fuera de los inputs de build. Una aplicación puede declarar que requiere DATABASE_URL y LOG_LEVEL, pero la contraseña real y la dirección del servicio de producción no deberían acabar horneadas en una imagen. SecretSpec distingue declaración de secretos y provisión en runtime; un sistema equivalente de un proveedor cloud puede resolver la misma separación.
| Recurso | Conviene versionar o fijar | Conviene resolver al desplegar |
|---|---|---|
| Fuente, manifest y dependencias | Commit + lockfiles revisados | — |
| Salida de build | Store path y/o digest de imagen | Registro y permisos de descarga |
| Contrato de configuración | Nombres, tipos y validaciones | Valores por entorno |
| Secretos | Nombres, políticas y rotación | Valor desde almacén de secretos |
| Base de datos | Migraciones y contratos compatibles | Datos, replicación y backups |
| Red y host | Definición de servicios, puertos deseados | DNS real, certificados, kernel, proveedor |
Esta separación tiene consecuencias al revertir. Una imagen anterior podría ejecutar contra un esquema de base de datos ya migrado. Para una reversión segura hacen falta migraciones compatibles hacia adelante/atrás, estrategia de despliegue expand/contract cuando corresponda y pruebas de restauración. Cambiar el digest no devuelve la base de datos a su estado anterior.
Probar el contrato de despliegue, no solo el compilador
El pipeline debería acumular evidencias según su coste y la cercanía a producción. Propongo este orden, que no supone mediciones ya ejecutadas:
- Antes de construir: validar lockfiles, revisión de dependencias, lint, tests unitarios y políticas de workflow.
- Durante el build: controlar arquitecturas, registrar input digests, generar el artefacto una sola vez y almacenar sus metadatos.
- Antes de promocionar: ejecutar smoke tests sobre ese artefacto, verificar el digest/procedencia y probar configuración requerida sin exponer secretos.
- Después de desplegar: revisar readiness real y un flujo funcional de la aplicación; conservar acceso al artefacto anterior.
- Ante un fallo: poder recuperar el digest anterior, estudiar compatibilidad del esquema y ejecutar el plan separado de recuperación de datos.
Los health checks no son equivalentes a un test de negocio y el éxito de un workflow no observa la red de producción. En especial, cualquier validación que dependa de bases de datos, relojes, servicios externos y mensajes debe registrar sus condiciones. La CI que describimos aquí no ha sido ejecutada para este artículo: son decisiones y comandos respaldados documentalmente, no resultados experimentales.
El coste de controlar más variables
Pinear acciones por commit exige mantener las referencias; construir imágenes por plataforma consume tiempo y caché; firmar y verificar provenance requiere permisos y políticas; los artefactos antiguos necesitan retención; los secretos necesitan rotación. En una aplicación pequeña estos costes pueden superar el beneficio inicial. Para un servicio de una sola plataforma y pocas dependencias, un Dockerfile bien revisado y un registry pueden ser suficientes. Nix/devenv aporta más cuando ya es el lenguaje común de los toolchains y del build.
La afirmación final no es que “producción es igual a desarrollo”. Es más precisa: sabemos de qué commit y locks procede el artefacto que se ejecuta; CI y el entorno de despliegue comparten su identidad, no necesariamente su estado. Si surge una divergencia, queda claro si buscarla en el build, en la configuración o en el sistema operativo y los datos. Ese es el punto de partida de un pipeline defendible.
Para completar la operación de una imagen OCI por digest —proxy, secretos, volúmenes, backups y reversión— continúa con el análisis de Coolify.