{"id":601,"date":"2026-07-22T08:16:55","date_gmt":"2026-07-22T08:16:55","guid":{"rendered":"https:\/\/matforge.org\/?p=601","raw":"https:\/\/matforge.org\/?p=601"},"modified":"2026-07-22T08:16:55","modified_gmt":"2026-07-22T08:16:55","slug":"reproducible-research-workflows-docker-and-conda-for-simulation-projects","status":"publish","type":"post","link":"https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/","title":{"rendered":"Flujos de trabajo de investigaci\u00f3n reproducibles: Docker y Conda para proyectos de simulaci\u00f3n","raw":"Flujos de trabajo de investigaci\u00f3n reproducibles: Docker y Conda para proyectos de simulaci\u00f3n"},"content":{"rendered":"<span class=\"span-reading-time rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Reading Time: <\/span> <span class=\"rt-time\"> 11<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span><p>Los flujos de trabajo de investigaci\u00f3n reproducibles garantizan que los resultados de la simulaci\u00f3n puedan ser creados exactamente por otros (o su futuro yo) utilizando los mismos datos, c\u00f3digo y entorno computacional. <strong>Docker<\/strong> Proporciona una completa contenedorizaci\u00f3n a nivel de sistema para una m\u00e1xima coherencia en todas las plataformas, mientras que <strong>conda<\/strong> ofrece una gesti\u00f3n de paquetes y entornos livianos ideales para la computaci\u00f3n cient\u00edfica basada en Python. Para proyectos de simulaci\u00f3n, recomendamos: (1) utilizar Conda para el desarrollo diario y la gesti\u00f3n de dependencias, (2) crear im\u00e1genes de Docker para \u00abcongelar\u00bb entornos de trabajo para publicaci\u00f3n y colaboraci\u00f3n, y (3) emparejar siempre con control de versiones y documentaci\u00f3n completa. Evite el error com\u00fan de confiar \u00fanicamente en una herramienta: combinar ambos para una reproducibilidad s\u00f3lida.<\/p>\n<h2>Introducci\u00f3n: la brecha de reproducibilidad en la investigaci\u00f3n de simulaci\u00f3n<\/h2>\n<p>Los proyectos de simulaci\u00f3n cient\u00edfica a menudo sufren de un modo de falla silenciosa: el c\u00f3digo funcion\u00f3 ayer, pero hoy produce resultados diferentes. La f\u00edsica subyacente no ha cambiado, su entorno computacional s\u00ed lo ha hecho. Las versiones de paquetes faltantes, las dependencias de biblioteca alteradas, las actualizaciones del sistema operativo o incluso los diferentes int\u00e9rpretes de Python pueden alterar silenciosamente las salidas de simulaci\u00f3n, a veces de maneras dif\u00edciles de detectar.<\/p>\n<p>Esto es m\u00e1s que un inconveniente. <strong>Reproducibilidad<\/strong> es la piedra angular de la ciencia acumulativa: la capacidad de otros investigadores de verificar afirmaciones y construir sobre su trabajo. Cuando los resultados de la simulaci\u00f3n no se pueden recrear de manera confiable, la confianza se erosiona, los documentos se retraen y se desperdicia un tiempo valioso de investigaci\u00f3n depurando problemas ambientales en lugar de avanzar en el conocimiento.<\/p>\n<p>En esta gu\u00eda, examinaremos c\u00f3mo implementar flujos de trabajo de investigaci\u00f3n reproducibles para proyectos de simulaci\u00f3n utilizando <strong>docker<\/strong> y <strong>conda<\/strong>, dos herramientas complementarias que, cuando se usan juntas, brindan una soluci\u00f3n s\u00f3lida para la consistencia del entorno, la gesti\u00f3n de dependencias y la preservaci\u00f3n a largo plazo. de m\u00e9todos computacionales.<\/p>\n<h2>\u00bfQu\u00e9 es la investigaci\u00f3n reproducible? Definiciones y componentes centrales<\/h2>\n<p>En esencia, <strong>investigaci\u00f3n reproducible<\/strong> significa que un investigador independiente puede regenerar los resultados publicados (tablas, figuras, hallazgos cuantitativos) utilizando solo los datos, el c\u00f3digo y la documentaci\u00f3n originales. Tal como se define por la V\u00eda Turing y ampliamente adoptado en la Ciencia Computacional, esto requiere:<\/p>\n<ul>\n<li><strong>Disponibilidad de datos<\/strong>: se puede acceder a los datos de entrada sin procesar (con consideraciones de privacidad adecuadas)<\/li>\n<li><strong>transparencia de c\u00f3digos<\/strong>: todos los scripts de an\u00e1lisis y simulaci\u00f3n se comparten<\/li>\n<li><strong>Documentaci\u00f3n<\/strong>: registros completos de versiones de software, par\u00e1metros y configuraciones de entorno<\/li>\n<li><strong>Control de entorno de c\u00e1lculo<\/strong>: el entorno de ejecuci\u00f3n exacto se captura y se reconstruye<\/li>\n<\/ul>\n<p>La reproducibilidad computacional difiere de la <strong>replicabilidad<\/strong> (obteniendo conclusiones similares utilizando nuevos datos o m\u00e9todos independientes). La reproducibilidad es el est\u00e1ndar m\u00ednimo: se trata de obtener los mismos n\u00fameros de las mismas entradas, no de validar las afirmaciones cient\u00edficas subyacentes.<\/p>\n<blockquote>\n<p><strong>Por qu\u00e9 es importante para los proyectos de simulaci\u00f3n<\/strong>: los solucionadores de PDE, los m\u00e9todos de elementos finitos y otros marcos de simulaci\u00f3n a menudo involucran cadenas de dependencia complejas. Un cambio de versi\u00f3n menor en una biblioteca num\u00e9rica puede alterar el comportamiento de discretizaci\u00f3n, los criterios de convergencia o el redondeo, produciendo resultados medibles diferentes. Los flujos de trabajo reproducibles eliminan esta fuente de incertidumbre.<\/p>\n<\/blockquote>\n<h2>Docker para simulaciones cient\u00edficas reproducibles<\/h2>\n<h3>Lo que proporciona Docker<\/h3>\n<p><strong>Docker<\/strong> es una plataforma de containerizaci\u00f3n que empaqueta una aplicaci\u00f3n y todo su entorno de ejecuci\u00f3n (sistema operativo, bibliotecas, dependencias, archivos de configuraci\u00f3n) en una imagen port\u00e1til e inmutable. Cuando ejecuta un contenedor de Docker, est\u00e1 ejecutando exactamente el mismo entorno que se cre\u00f3 y prob\u00f3, independientemente del sistema host.<\/p>\n<p>Para proyectos de simulaci\u00f3n, Docker ofrece:<\/p>\n<ol>\n<li><strong>Consistencia ambiental<\/strong>: no m\u00e1s \u00abfunciona en mi m\u00e1quina\u00bb. El contenedor incluye versiones espec\u00edficas de compiladores, implementaciones de MPI, int\u00e9rpretes de Python y bibliotecas num\u00e9ricas.<\/li>\n<li><strong>Portabilidad de la plataforma<\/strong>: una imagen de Docker creada en una computadora port\u00e1til puede ejecutarse en un cl\u00faster de HPC, una instancia en la nube o una estaci\u00f3n de trabajo de colega sin modificaciones.<\/li>\n<li><strong>Aislamiento<\/strong>: Las dependencias de simulaci\u00f3n no entran en conflicto con las bibliotecas del sistema u otros proyectos.<\/li>\n<li><strong>Instant\u00e1neas versionadas<\/strong>: cada imagen de Docker es inmutable y se puede etiquetar (por ejemplo, <code>my-sim:paper-v1<\/code>) para una reproducci\u00f3n futura exacta.<\/li>\n<\/ol>\n<h3>Limitaciones de Docker a considerar<\/h3>\n<p>A pesar de sus fortalezas, Docker tiene limitaciones importantes para la computaci\u00f3n cient\u00edfica:<\/p>\n<ul>\n<li><strong>No es una bala de plata<\/strong>: como se indica en \u00abDocker no garantiza la reproducibilidad\u00bb (ARXIV 2026), los contenedores a\u00fan pueden mostrar un comportamiento no determinista si el hardware subyacente difiere (arquitectura de CPU, optimizaciones de punto flotante) o si servicios externos (base de datos, sistema de archivos) var\u00edan.<\/li>\n<li><strong>Dependencia del kernel<\/strong>: los contenedores de Docker comparten el kernel de host. Esto significa que el comportamiento del contenedor a\u00fan puede verse afectado por la versi\u00f3n y la configuraci\u00f3n del kernel del host.<\/li>\n<li><strong>Tama\u00f1o de sobrecarga<\/strong>: Las im\u00e1genes del sistema operativo completo pueden ser grandes (cientos de MB a GB), aunque las im\u00e1genes delgadas como <code>alpine<\/code> ayudan.<\/li>\n<li><strong>Restricciones de HPC<\/strong>: Muchos centros de HPC no permiten el Docker directamente debido a problemas de seguridad; Usan <strong>Singularity<\/strong> o <strong>apptainer<\/strong> en su lugar. Sin embargo, puede crear im\u00e1genes de singularidad a partir de im\u00e1genes de Docker, lo que convierte a Docker en una herramienta de desarrollo viable.<\/li>\n<\/ul>\n<h3>Escribir archivos Docker para proyectos de simulaci\u00f3n<\/h3>\n<p><strong>DockerFile<\/strong> define c\u00f3mo crear su contenedor. Siguiendo \u00abDiez reglas simples para escribir archivos Docker para la investigaci\u00f3n reproducible\u00bb (N\u00fcst et al., 2020), las pr\u00e1cticas clave incluyen:<\/p>\n<pre><code class=\"language-dockerfile\"># Start from a minimal, pinned base image\nFROM ubuntu:22.04  # Pin exact version, not :latest\n\n# Set environment variables for reproducibility\nENV LANG=C.UTF-8\nENV LC_ALL=C.UTF-8\n\n# Install system dependencies in one layer to minimize cache issues\nRUN apt-get update &amp;&amp; apt-get install -y \n    python3 \n    python3-pip \n    libopenblas-dev \n    &amp;&amp; rm -rf \/var\/lib\/apt\/lists\/*\n\n# Create and set working directory\nWORKDIR \/simulation\n\n# Copy dependency specifications first (for better caching)\nCOPY requirements.txt environment.yml .\/\n\n# Install Python packages with pinned versions\nRUN pip install --no-cache-dir -r requirements.txt\n\n# Copy simulation code\nCOPY src\/ .\/src\/\nCOPY scripts\/ .\/scripts\/\nCOPY data\/ .\/data\/\n\n# Define entry point or command\nENTRYPOINT [\"python3\", \"scripts\/run_simulation.py\"]\n<\/code><\/pre>\n<p><strong>Regla de teclas<\/strong>: anclar expl\u00edcitamente todas las versiones: imagen base, paquetes de sistema operativo, paquetes de Python e incluso versi\u00f3n PIP. Use <code>requirements.txt<\/code> o <code>environment.yml<\/code> con versiones exactas (<code>package==1.2.3<\/code>, no <code>package&gt;=1.0<\/code>).<\/p>\n<h2>CONDA para la gesti\u00f3n del medio ambiente en investigaci\u00f3n<\/h2>\n<h3>Lo que proporciona Conda<\/h3>\n<p><strong>Conda<\/strong> es un administrador de paquetes y entornos multiplataforma que maneja no solo paquetes de Python, sino tambi\u00e9n dependencias que no son de Python (bibliotecas C\/C++, compiladores, MPI). Esto lo hace particularmente adecuado para la simulaci\u00f3n cient\u00edfica en la que es posible que necesite versiones espec\u00edficas de OpenMPi, FFTW o HDF5.<\/p>\n<p>Conda entrega:<\/p>\n<ol>\n<li><strong>Agn\u00f3stico de lenguaje<\/strong>: instale las bibliotecas Python, R, C\/C++ y las herramientas del sistema en un entorno.<\/li>\n<li><strong>Dependencias binarias<\/strong>: los paquetes precompilados evitan la compilaci\u00f3n del infierno en diferentes sistemas.<\/li>\n<li><strong>Entornos aislados<\/strong>: cada proyecto tiene su propio entorno sin contaminaci\u00f3n cruzada.<\/li>\n<li><strong>Exportar\/Importar<\/strong>: <code>conda env export &gt; environment.yml<\/code> Captura todo el entorno para una reproducci\u00f3n exacta.<\/li>\n<\/ol>\n<h3>Mejores pr\u00e1cticas de Conda<\/h3>\n<p>Basado en la gu\u00eda de MSI de la Universidad de Minnesota y Anaconda:<\/p>\n<ul>\n<li><strong>Nunca instale en <code>base<\/code><\/strong>: cree un nuevo entorno para cada proyecto:\n<pre><code class=\"language-bash\">conda create --name my-simulation python=3.11\nconda activate my-simulation\n<\/code><\/pre>\n<\/li>\n<li><strong>Utilice los canales de la comunidad<\/strong>: prefiera <code>conda-forge<\/code> sobre los valores predeterminados para paquetes cient\u00edficos m\u00e1s actualizados:\n<pre><code class=\"language-bash\">conda config --add channels conda-forge\nconda config --set channel_priority strict\n<\/code><\/pre>\n<\/li>\n<li><strong>Instalar todos los paquetes a la vez<\/strong>: Esto evita conflictos de dependencias:\n<pre><code class=\"language-bash\">conda install numpy scipy matplotlib fipy\n<\/code><\/pre>\n<\/li>\n<li><strong>No modifique los entornos existentes<\/strong>: si necesita paquetes nuevos, actualice la especificaci\u00f3n del entorno o cree un entorno nuevo a partir del archivo YAML actualizado.<\/li>\n<li><strong>Exportar limpiamente<\/strong>: al compartir, elimine paquetes espec\u00edficos de la plataforma y elementos instalados por PIP que no son esenciales:\n<pre><code class=\"language-bash\">conda env export --no-builds | grep -v \"prefix:\" &gt; environment.yml\n<\/code><\/pre>\n<\/li>\n<\/ul>\n<h2>Docker vs Conda: cu\u00e1ndo elegir cu\u00e1l<\/h2>\n<p>La pregunta no es \u00ab\u00bfDocker o Conda?\u00bb: resuelven diferentes problemas y son <strong>complementarios<\/strong>.<\/p>\n<table>\n<thead>\n<tr>\n<th>Aspecto<\/th>\n<th>Estibador<\/th>\n<th>condaci\u00f3n<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><strong>\u00c1mbito<\/strong><\/td>\n<td>Sistema operativo completo + tiempo de ejecuci\u00f3n<\/td>\n<td>Paquete y Amp; Gerente de Ambiente<\/td>\n<\/tr>\n<tr>\n<td><strong>aislamiento<\/strong><\/td>\n<td>Nivel de sistema (espacio de nombres del kernel)<\/td>\n<td>Entorno de espacio de usuario<\/td>\n<\/tr>\n<tr>\n<td><strong>Tama\u00f1o<\/strong><\/td>\n<td>Grande (100 MB\u20131 GB+)<\/td>\n<td>Peque\u00f1o (MBS)<\/td>\n<\/tr>\n<tr>\n<td><strong>velocidad<\/strong><\/td>\n<td>M\u00e1s lento para construir\/transferir<\/td>\n<td>Activaci\u00f3n instant\u00e1nea<\/td>\n<\/tr>\n<tr>\n<td><strong>Soporte HPC<\/strong><\/td>\n<td>Limitado (funciona la singularidad)<\/td>\n<td>Excelente (nativo)<\/td>\n<\/tr>\n<tr>\n<td><strong>Caso de uso<\/strong><\/td>\n<td>Publicar, compartir, despliegue<\/td>\n<td>Desarrollo diario, exploraci\u00f3n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h3>Recomendaci\u00f3n pr\u00e1ctica<\/h3>\n<ul>\n<li><strong>Utilice conda para el desarrollo<\/strong>: cree r\u00e1pidamente entornos aislados, pruebe las dependencias e iterar\u00e1 en el c\u00f3digo. Es ligero y r\u00e1pido.<\/li>\n<li><strong>Utilice Docker para la conservaci\u00f3n<\/strong>: una vez que su simulaci\u00f3n funcione, cree una imagen de Docker para \u00abcongelar\u00bb el entorno exacto. Comparta esta imagen con colaboradores, adj\u00fantela a publicaciones o \u00fasela para CI\/CD.<\/li>\n<li><strong>Combine ambos<\/strong>: desarrolle en conda, luego cree un dockerfile que:\n<ul>\n<li>copia el entorno de conda en la imagen, o<\/li>\n<li>recrea el entorno utilizando <code>environment.yml<\/code><\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<p>Este enfoque en capas le brinda agilidad de desarrollo y robustez de publicaci\u00f3n.<\/p>\n<h2>Integraci\u00f3n de Docker y Conda en flujos de trabajo cient\u00edficos<\/h2>\n<h3>Estrategia 1: Conda dentro de Docker<\/h3>\n<p>La integraci\u00f3n m\u00e1s com\u00fan es instalar y usar conda dentro de un contenedor docker. Esto le brinda la administraci\u00f3n de paquetes de gran tama\u00f1o de Conda dentro del aislamiento del sistema de Docker.<\/p>\n<pre><code class=\"language-dockerfile\">FROM ubuntu:22.04\n\n# Install Miniconda\nRUN wget https:\/\/repo.anaconda.com\/miniconda\/Miniconda3-latest-Linux-x86_64.sh \n    &amp;&amp; bash Miniconda3-latest-Linux-x86_64.sh -b -p \/opt\/conda \n    &amp;&amp; rm Miniconda3-latest-Linux-x86_64.sh\nENV PATH=\/opt\/conda\/bin:$PATH\n\n# Create and use a conda environment\nCOPY environment.yml .\nRUN conda env create -f environment.yml\nENV PATH=\/opt\/conda\/envs\/my-sim\/bin:$PATH\n<\/code><\/pre>\n<p><strong>Pros<\/strong>: Aprovecha el extenso ecosistema de paquetes cient\u00edficos de CONDA; consistente con los flujos de trabajo de desarrollo local.<br \/> <strong>cons<\/strong>: tama\u00f1o de imagen m\u00e1s grande; Matices de activaci\u00f3n de conda en Docker.<\/p>\n<h3>Estrategia 2: Docker para la captura del entorno<\/h3>\n<p>Desarrolle localmente con Conda, luego exporte el entorno y hornee en una imagen de Docker sin ejecutar Conda en tiempo de ejecuci\u00f3n:<\/p>\n<pre><code class=\"language-dockerfile\">FROM python:3.11-slim\n\n# Copy pre-built packages or use pip from a frozen requirements.txt\nCOPY requirements.txt .\nRUN pip install --no-cache-dir -r requirements.txt\n<\/code><\/pre>\n<p>Esto es m\u00e1s simple pero pierde el manejo de dependencias que no son de Python de Conda.<\/p>\n<h3>Estrategia 3: Construcciones de varias etapas para HPC<\/h3>\n<p>Para los cl\u00fasteres de HPC que usan Singularity, cree la imagen de Docker localmente y luego convi\u00e9rtala en singularidad:<\/p>\n<pre><code class=\"language-bash\">docker build -t my-sim:latest .\nsingularity build my-sim.sif docker:\/\/my-sim:latest\n<\/code><\/pre>\n<p>Este flujo de trabajo le permite desarrollar con Docker (Easy Testing) e implementar en HPC (Singularity).<\/p>\n<h2>Trampas comunes y c\u00f3mo evitarlas<\/h2>\n<p>Bas\u00e1ndose en el an\u00e1lisis de los desaf\u00edos de reproducibilidad en la investigaci\u00f3n de simulaci\u00f3n, aqu\u00ed hay errores cr\u00edticos a evitar:<\/p>\n<h3>1. <strong>Documentaci\u00f3n desaparecida o incompleta<\/strong><\/h3>\n<p><strong>Problema<\/strong>: tiene una imagen de Docker que funciona, pero no tiene registro de c\u00f3mo usarla, qu\u00e9 entradas espera o c\u00f3mo interpretar las salidas.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>: incluye un <code>README.md<\/code> en el contenedor (o junto a la imagen) con:<\/p>\n<ul>\n<li>C\u00f3mo ejecutar la simulaci\u00f3n (argumentos de l\u00ednea de comandos)<\/li>\n<li>Formatos de archivo de entrada esperados<\/li>\n<li>Descripciones de archivos de salida<\/li>\n<li>Requisitos de hardware (CPU, memoria, GPU)<\/li>\n<li>Limitaciones conocidas<\/li>\n<\/ul>\n<h3>2. <strong>Dependencias no ancladas<\/strong><\/h3>\n<p><strong>Problema<\/strong>: El uso de <code>numpy&gt;=1.0<\/code> o <code>python=3.x<\/code> permite actualizaciones autom\u00e1ticas que pueden cambiar el comportamiento.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>: PIN Versiones exactas en <code>environment.yml<\/code> y <code>requirements.txt<\/code>:<\/p>\n<pre><code class=\"language-yaml\">dependencies:\n  - python=3.11.8\n  - numpy=1.26.4\n  - scipy=1.11.4\n  - pip:\n    - my-package==0.3.2\n<\/code><\/pre>\n<h3>3. <strong>Simulaciones no deterministas<\/strong><\/h3>\n<p><strong>Problema<\/strong>: incluso con entornos id\u00e9nticos, las simulaciones producen resultados ligeramente diferentes debido a la no asociatividad de punto flotante, las condiciones de carrera paralelas o la memoria no inicializada.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>:<\/p>\n<ul>\n<li>Establezca banderas deterministas donde est\u00e9 disponible (por ejemplo, OpenMP <code>OMP_NUM_THREADS=1<\/code>, enhebrado blas)<\/li>\n<li>Use semillas aleatorias fijas y docum\u00e9ntelas<\/li>\n<li>Pruebe la reproducibilidad ejecutando el contenedor varias veces en el mismo host<\/li>\n<\/ul>\n<h3>4. <strong>Grandes datos dentro de contenedores<\/strong><\/h3>\n<p><strong>Problema<\/strong>: hornear grandes conjuntos de datos de simulaci\u00f3n en im\u00e1genes de Docker los infla y hace que la distribuci\u00f3n sea lenta.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>: Mantenga los datos externos. Utilice los vol\u00famenes de Docker o los montajes de enlace para adjuntar datos en tiempo de ejecuci\u00f3n:<\/p>\n<pre><code class=\"language-bash\">docker run -v \/path\/to\/data:\/data my-sim:latest\n<\/code><\/pre>\n<p>Documente las expectativas de los datos claramente.<\/p>\n<h3>5. <strong>Ignorar las restricciones de HPC<\/strong><\/h3>\n<p><strong>Problema<\/strong>: las im\u00e1genes de Docker que funcionan en una computadora port\u00e1til fallan en un cl\u00faster de HPC debido a que faltan implementaciones de MPI, controladores incompatibles o restricciones de seguridad.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>:<\/p>\n<ul>\n<li>Pruebe en un entorno similar a un cl\u00faster temprano<\/li>\n<li>Usar compatibilidad de singularidad al dirigirse a HPC<\/li>\n<li>Evite los patrones de Docker-in-Docker; Construya sobre una imagen base que coincida con el sistema operativo de cl\u00faster (por ejemplo, CentOS\/Rocky si el cl\u00faster usa esos)<\/li>\n<\/ul>\n<h3>6. <strong>No hay control de versiones para archivos de Dockerfiles y de entorno<\/strong><\/h3>\n<p><strong>Problema<\/strong>: tiene una imagen de trabajo pero no tiene historial de cambios en el archivo dockerfile o <code>environment.yml<\/code>.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>: Trate las especificaciones de Dockerfile y Environment como <strong>c\u00f3digo<\/strong>. Gu\u00e1rdelos en Git junto con su c\u00f3digo de simulaci\u00f3n. Liberaciones de etiquetas (por ejemplo, <code>git tag -a v1.0 -m \"Paper submission\"<\/code>).<\/p>\n<h3>7. <strong>Con vistas a los servicios externos<\/strong><\/h3>\n<p><strong>Problema<\/strong>: su simulaci\u00f3n extrae datos de una base de datos o API que cambia con el tiempo, rompiendo la reproducibilidad.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>: O bien:<\/p>\n<ul>\n<li>Snapshot datos externos e incl\u00fayalos en su repositorio o contenedor, o<\/li>\n<li>Use puntos finales de API versionados y documente la versi\u00f3n\/fecha exacta a la que se accede<\/li>\n<\/ul>\n<h2>Consideraciones de HPC y cl\u00faster<\/h2>\n<p>Los entornos inform\u00e1ticos de alto rendimiento introducen desaf\u00edos de reproducibilidad adicionales:<\/p>\n<h3>Singularity\/Aptainer en lugar de Docker<\/h3>\n<p>La mayor\u00eda de los centros de HPC proh\u00edben Docker por razones de seguridad. En cambio, proporcionan <strong>singularity<\/strong> (o su bifurcaci\u00f3n <strong>apptainer<\/strong>). Los contenedores de singularidad se construyen a partir de im\u00e1genes de Docker:<\/p>\n<pre><code class=\"language-bash\"># On your local machine with Docker\ndocker pull ubuntu:22.04\ndocker tag ubuntu:22.04 my-sim:base\n\n# Build your image as usual\ndocker build -t my-sim:latest .\n\n# Transfer image to HPC and convert\nsingularity build my-sim.sif docker:\/\/my-sim:latest\n<\/code><\/pre>\n<p><strong>Diferencia clave<\/strong>: Singularity ejecuta contenedores como el usuario invocador (sin root), por lo que las rutas de instalaci\u00f3n del paquete difieren. Pruebe su Dockerfile con singularidad para detectar problemas temprano.<\/p>\n<h3>Sistemas de m\u00f3dulos<\/h3>\n<p>Muchos cl\u00fasteres de HPC utilizan <strong>M\u00f3dulos de entorno<\/strong> (LMOD) para administrar las versiones de software. Puedes:<\/p>\n<ul>\n<li>Cargue los m\u00f3dulos necesarios antes de ejecutar su contenedor (si la singularidad puede acceder a ellos), o<\/li>\n<li>Construya su contenedor en una imagen base que ya incluya las bibliotecas necesarias<\/li>\n<\/ul>\n<h3>E\/S en paralelo y MPI<\/h3>\n<p>Si su simulaci\u00f3n utiliza MPI (interfaz de paso de mensajes), aseg\u00farese de que su contenedor incluya una implementaci\u00f3n MPI compatible. Para singularidad, puede <strong>bind-mount<\/strong> las bibliotecas MPI del host:<\/p>\n<pre><code class=\"language-bash\">singularity run --nv -B \/usr\/lib\/x86_64-linux-gnu\/openmpi:\/usr\/lib\/x86_64-linux-gnu\/openmpi my-sim.sif\n<\/code><\/pre>\n<p>Alternativamente, instale MPich o OpenMPi dentro del contenedor y aseg\u00farese de que est\u00e9 configurado para usar la estructura de red del host (InfiniBand, etc.).<\/p>\n<h3>Soporte de GPU<\/h3>\n<p>Para las simulaciones aceleradas por GPU, tanto Docker como Singularity requieren banderas especiales:<\/p>\n<ul>\n<li>Docker: <code>--gpus all<\/code><\/li>\n<li>Singularidad: <code>--nv<\/code><\/li>\n<\/ul>\n<p>Pruebe la funcionalidad de la GPU a fondo en su contenedor.<\/p>\n<h2>Gu\u00eda de implementaci\u00f3n paso a paso<\/h2>\n<p>Aqu\u00ed hay un flujo de trabajo pr\u00e1ctico para implementar flujos de trabajo de investigaci\u00f3n reproducibles en su proyecto de simulaci\u00f3n:<\/p>\n<h3>Fase 1: Configuraci\u00f3n del proyecto<\/h3>\n<ol>\n<li><strong>Control de versi\u00f3n inicial<\/strong> (git):\n<pre><code class=\"language-bash\">git init\ngit add .\ngit commit -m \"Initial project structure\"\n<\/code><\/pre>\n<\/li>\n<li><strong>Crear entorno de conda<\/strong>:\n<pre><code class=\"language-bash\">conda create --name my-sim python=3.11\nconda activate my-sim\n<\/code><\/pre>\n<\/li>\n<li><strong>Instalar dependencias<\/strong> y registrarlas:\n<pre><code class=\"language-bash\">conda install numpy scipy matplotlib fipy  # Example for PDE simulations\nconda env export --no-builds | grep -v \"prefix:\" &gt; environment.yml\n<\/code><\/pre>\n<\/li>\n<li><strong>Crear estructura de proyecto<\/strong>:\n<pre><code>my-simulation\/\n\u251c\u2500\u2500 src\/              # Source code\n\u251c\u2500\u2500 scripts\/          # Run scripts, entry points\n\u251c\u2500\u2500 data\/             # Input data (git-ignored if large)\n\u251c\u2500\u2500 outputs\/          # Generated results (git-ignored)\n\u251c\u2500\u2500 docs\/             # Documentation\n\u251c\u2500\u2500 environment.yml   # Conda environment\n\u251c\u2500\u2500 requirements.txt  # Pip-only dependencies (if any)\n\u251c\u2500\u2500 Dockerfile        # Container definition\n\u251c\u2500\u2500 README.md         # Usage instructions\n\u2514\u2500\u2500 .gitignore        # Exclude outputs, large data\n<\/code><\/pre>\n<\/li>\n<\/ol>\n<h3>Fase 2: Desarrollo con Conda<\/h3>\n<ul>\n<li>Desarrollar y probar dentro del entorno CONDA<\/li>\n<li>Confirmar cambios de c\u00f3digo con frecuencia<\/li>\n<li>Actualizar <code>environment.yml<\/code> al agregar\/eliminar paquetes<\/li>\n<li>Use <code>.gitignore<\/code> para excluir salidas generadas y archivos de datos grandes<\/li>\n<\/ul>\n<h3>Fase 3: Construyendo la imagen de Docker<\/h3>\n<ol>\n<li><strong>Crear un archivo docker<\/strong> (ver ejemplo arriba)<\/li>\n<li><strong>Construye la imagen<\/strong>:\n<pre><code class=\"language-bash\">docker build -t my-sim:latest .\n<\/code><\/pre>\n<\/li>\n<li><strong>Prueba el contenedor<\/strong>:\n<pre><code class=\"language-bash\">docker run -v $(pwd)\/data:\/data my-sim:latest python scripts\/run_simulation.py --input \/data\/input.h5\n<\/code><\/pre>\n<\/li>\n<li><strong>Tag para publicaci\u00f3n<\/strong>:\n<pre><code class=\"language-bash\">docker tag my-sim:latest my-sim:paper-v1.0\n<\/code><\/pre>\n<\/li>\n<li><strong>Pulse al registro<\/strong> (opcional, para compartir):\n<pre><code class=\"language-bash\">docker push my-registry.example.com\/my-sim:paper-v1.0\n<\/code><\/pre>\n<\/li>\n<\/ol>\n<h3>Fase 4: Verificaci\u00f3n y Compartir<\/h3>\n<ol>\n<li><strong>Reproducibilidad de prueba<\/strong>: haga que un colega tire y ejecute la imagen. Deben obtener resultados id\u00e9nticos (bit por bit id\u00e9ntico si la simulaci\u00f3n es determinista).<\/li>\n<li><strong>Documento<\/strong>: Asegure <code>README.md<\/code> Incluye:\n<ul>\n<li>C\u00f3mo obtener la imagen (Docker Hub, Registro o <code>.sif<\/code> Archivo)<\/li>\n<li>C\u00f3mo ejecutarla (Comando completo)<\/li>\n<li> Especificaciones del archivo de entrada<\/li>\n<li>Archivos de salida esperados y sus formatos<\/li>\n<li>Informaci\u00f3n de citas<\/li>\n<\/ul>\n<\/li>\n<li><strong>Archivo<\/strong>: Deposite la imagen de Docker (o Singularity <code>.sif<\/code>) en un archivo a largo plazo como Zenodo o FigShare, e incluya el enlace en los m\u00e9todos de su documento o en la declaraci\u00f3n de disponibilidad de datos.<\/li>\n<\/ol>\n<h3>Fase 5: Mantenimiento a largo plazo<\/h3>\n<ul>\n<li>Al realizar cambios de c\u00f3digo, actualice la imagen de Docker y la etiqueta con una nueva versi\u00f3n (por ejemplo, <code>v1.1<\/code>)<\/li>\n<li>Mantenga im\u00e1genes\/etiquetas antiguas durante el tiempo que necesite reproducir resultados antiguos<\/li>\n<li>Use etiquetas Git para correlacionar confirmaciones de c\u00f3digo con versiones de imagen de Docker<\/li>\n<\/ul>\n<h2>Conclusi\u00f3n y pr\u00f3ximos pasos<\/h2>\n<p>La implementaci\u00f3n de flujos de trabajo de investigaci\u00f3n reproducibles no es una decisi\u00f3n de herramienta \u00fanica, es una <strong>estrategia en capas<\/strong>:<\/p>\n<ul>\n<li><strong>Conda<\/strong> para una gesti\u00f3n del entorno ligero y r\u00e1pido durante el desarrollo<\/li>\n<li><strong>Docker<\/strong> para instant\u00e1neas inmutables y port\u00e1tiles, adecuadas para la publicaci\u00f3n y la colaboraci\u00f3n<\/li>\n<li><strong>Git<\/strong> para el control de versiones de c\u00f3digo, dockerfiles y especificaciones de entorno<\/li>\n<li><strong>Documentaci\u00f3n<\/strong> para que el flujo de trabajo sea comprensible y utilizable por otros<\/li>\n<\/ul>\n<p>Para proyectos de simulaci\u00f3n donde la correcci\u00f3n y la verificabilidad son primordiales, esta combinaci\u00f3n proporciona una base s\u00f3lida. Comience con Conda para su pr\u00f3ximo proyecto, y una vez que la simulaci\u00f3n est\u00e9 funcionando, invierta el tiempo para crear una imagen de Docker. El costo inicial paga dividendos cuando usted (u otros) necesitan volver a ejecutar la simulaci\u00f3n meses o a\u00f1os despu\u00e9s con confianza.<\/p>\n<p><strong>Siguiente pasos que puedes tomar hoy:<\/strong><\/p>\n<ol>\n<li>Auditar sus proyectos de simulaci\u00f3n actuales: \u00bfEst\u00e1n documentados los entornos? \u00bfSe fijan las dependencias?<\/li>\n<li>Convierta un proyecto existente para utilizar entornos CONDA con <code>environment.yml<\/code><\/li>\n<li>Cree una imagen de Docker para una simulaci\u00f3n de trabajo y pru\u00e9bela en una m\u00e1quina diferente<\/li>\n<li>Explore las pol\u00edticas de singularidad de su centro de HPC y convierta una imagen de Docker a formato de singularidad<\/li>\n<li>Incluya especificaciones de entorno e im\u00e1genes de contenedores en los materiales complementarios de su pr\u00f3ximo documento<\/li>\n<\/ol>\n<h2>Gu\u00edas relacionadas<\/h2>\n<ul>\n<li><a href=\"\/managing-research-software-through-tickets\">administrar software de investigaci\u00f3n a trav\u00e9s de tickets<\/a> \u2013 Reproducibilidad de estructuras Trabajo como seguimiento de problemas y mejoras<\/li>\n<li><a href=\"\/managing-large-scale-pde-problems-strategies-solvers-and-hpc-case-studies\">Gesti\u00f3n de problemas de PDE a gran escala: estrategias, solucionadores y estudios de casos de HPC<\/a> \u2013 Escala sus simulaciones Mientras mantiene la reproducibilidad<\/li>\n<li><a href=\"\/tracking-long-term-technical-debt-in-research-software\">seguimiento de la deuda t\u00e9cnica en el software de investigaci\u00f3n<\/a>: use pr\u00e1cticas de CI\/CD para mantener la reproducibilidad a lo largo del tiempo<\/li>\n<li><a href=\"\/collaboration-between-developers-and-researchers-turning-innovation-into-scalable-impact\">Colaboraci\u00f3n entre desarrolladores e investigadores<\/a> \u2013 Asegurar la reproducibilidad a trav\u00e9s de los l\u00edmites del equipo<\/li>\n<\/ul>\n<h2>Referencias y lectura adicional<\/h2>\n<ul>\n<li>Boettiger, C. (2015). <a href=\"https:\/\/doi.org\/10.1145\/2723872.2723882\">Una introducci\u00f3n a Docker para la investigaci\u00f3n reproducible<\/a>. <em>Revisi\u00f3n de sistemas operativos ACM SIGOPS<\/em>.<\/li>\n<li>N\u00fcst, D., et al. (2020). <a href=\"https:\/\/doi.org\/10.1371\/journal.pcbi.1008319\">Diez reglas simples para escribir Dockerfiles para la ciencia de datos reproducibles<\/a>. <em>PLOS Biolog\u00eda computacional<\/em>.<\/li>\n<li>El Camino de Turing. <a href=\"https:\/\/book.the-turing-way.org\/reproducible-research\/overview\/overview-definitions\/\">definiciones de investigaci\u00f3n reproducible<\/a>.<\/li>\n<li>Fitzpatrick, B. G., et al. (2018). <a href=\"https:\/\/doi.org\/10.3389\/fcomp.2018.00001\">Problemas en la investigaci\u00f3n de simulaci\u00f3n reproducible<\/a>. <em>Fronteras en Ciencias de la Computaci\u00f3n<\/em>.<\/li>\n<li>Documentaci\u00f3n de Conda. <a href=\"https:\/\/docs.conda.io\/projects\/conda\/en\/stable\/user-guide\/tasks\/manage-environments.html\">administraci\u00f3n de entornos<\/a>.<\/li>\n<\/ul>\n","protected":false,"raw":"<p>Los flujos de trabajo de investigaci\u00f3n reproducibles garantizan que los resultados de la simulaci\u00f3n puedan ser creados exactamente por otros (o su futuro yo) utilizando los mismos datos, c\u00f3digo y entorno computacional. <strong>Docker<\/strong> Proporciona una completa contenedorizaci\u00f3n a nivel de sistema para una m\u00e1xima coherencia en todas las plataformas, mientras que <strong>conda<\/strong> ofrece una gesti\u00f3n de paquetes y entornos livianos ideales para la computaci\u00f3n cient\u00edfica basada en Python. Para proyectos de simulaci\u00f3n, recomendamos: (1) utilizar Conda para el desarrollo diario y la gesti\u00f3n de dependencias, (2) crear im\u00e1genes de Docker para \"congelar\" entornos de trabajo para publicaci\u00f3n y colaboraci\u00f3n, y (3) emparejar siempre con control de versiones y documentaci\u00f3n completa. Evite el error com\u00fan de confiar \u00fanicamente en una herramienta: combinar ambos para una reproducibilidad s\u00f3lida.<\/p>\n<h2>Introducci\u00f3n: la brecha de reproducibilidad en la investigaci\u00f3n de simulaci\u00f3n<\/h2>\n<p>Los proyectos de simulaci\u00f3n cient\u00edfica a menudo sufren de un modo de falla silenciosa: el c\u00f3digo funcion\u00f3 ayer, pero hoy produce resultados diferentes. La f\u00edsica subyacente no ha cambiado, su entorno computacional s\u00ed lo ha hecho. Las versiones de paquetes faltantes, las dependencias de biblioteca alteradas, las actualizaciones del sistema operativo o incluso los diferentes int\u00e9rpretes de Python pueden alterar silenciosamente las salidas de simulaci\u00f3n, a veces de maneras dif\u00edciles de detectar.<\/p>\n<p>Esto es m\u00e1s que un inconveniente. <strong>Reproducibilidad<\/strong> es la piedra angular de la ciencia acumulativa: la capacidad de otros investigadores de verificar afirmaciones y construir sobre su trabajo. Cuando los resultados de la simulaci\u00f3n no se pueden recrear de manera confiable, la confianza se erosiona, los documentos se retraen y se desperdicia un tiempo valioso de investigaci\u00f3n depurando problemas ambientales en lugar de avanzar en el conocimiento.<\/p>\n<p>En esta gu\u00eda, examinaremos c\u00f3mo implementar flujos de trabajo de investigaci\u00f3n reproducibles para proyectos de simulaci\u00f3n utilizando <strong>docker<\/strong> y <strong>conda<\/strong>, dos herramientas complementarias que, cuando se usan juntas, brindan una soluci\u00f3n s\u00f3lida para la consistencia del entorno, la gesti\u00f3n de dependencias y la preservaci\u00f3n a largo plazo. de m\u00e9todos computacionales.<\/p>\n<h2>\u00bfQu\u00e9 es la investigaci\u00f3n reproducible? Definiciones y componentes centrales<\/h2>\n<p>En esencia, <strong>investigaci\u00f3n reproducible<\/strong> significa que un investigador independiente puede regenerar los resultados publicados (tablas, figuras, hallazgos cuantitativos) utilizando solo los datos, el c\u00f3digo y la documentaci\u00f3n originales. Tal como se define por la V\u00eda Turing y ampliamente adoptado en la Ciencia Computacional, esto requiere:<\/p>\n<ul>\n<li><strong>Disponibilidad de datos<\/strong>: se puede acceder a los datos de entrada sin procesar (con consideraciones de privacidad adecuadas)<\/li>\n<li><strong>transparencia de c\u00f3digos<\/strong>: todos los scripts de an\u00e1lisis y simulaci\u00f3n se comparten<\/li>\n<li><strong>Documentaci\u00f3n<\/strong>: registros completos de versiones de software, par\u00e1metros y configuraciones de entorno<\/li>\n<li><strong>Control de entorno de c\u00e1lculo<\/strong>: el entorno de ejecuci\u00f3n exacto se captura y se reconstruye<\/li>\n<\/ul>\n<p>La reproducibilidad computacional difiere de la <strong>replicabilidad<\/strong> (obteniendo conclusiones similares utilizando nuevos datos o m\u00e9todos independientes). La reproducibilidad es el est\u00e1ndar m\u00ednimo: se trata de obtener los mismos n\u00fameros de las mismas entradas, no de validar las afirmaciones cient\u00edficas subyacentes.<\/p>\n<blockquote><p><strong>Por qu\u00e9 es importante para los proyectos de simulaci\u00f3n<\/strong>: los solucionadores de PDE, los m\u00e9todos de elementos finitos y otros marcos de simulaci\u00f3n a menudo involucran cadenas de dependencia complejas. Un cambio de versi\u00f3n menor en una biblioteca num\u00e9rica puede alterar el comportamiento de discretizaci\u00f3n, los criterios de convergencia o el redondeo, produciendo resultados medibles diferentes. Los flujos de trabajo reproducibles eliminan esta fuente de incertidumbre.<\/p><\/blockquote>\n<h2>Docker para simulaciones cient\u00edficas reproducibles<\/h2>\n<h3>Lo que proporciona Docker<\/h3>\n<p><strong>Docker<\/strong> es una plataforma de containerizaci\u00f3n que empaqueta una aplicaci\u00f3n y todo su entorno de ejecuci\u00f3n (sistema operativo, bibliotecas, dependencias, archivos de configuraci\u00f3n) en una imagen port\u00e1til e inmutable. Cuando ejecuta un contenedor de Docker, est\u00e1 ejecutando exactamente el mismo entorno que se cre\u00f3 y prob\u00f3, independientemente del sistema host.<\/p>\n<p>Para proyectos de simulaci\u00f3n, Docker ofrece:<\/p>\n<ol>\n<li><strong>Consistencia ambiental<\/strong>: no m\u00e1s \"funciona en mi m\u00e1quina\". El contenedor incluye versiones espec\u00edficas de compiladores, implementaciones de MPI, int\u00e9rpretes de Python y bibliotecas num\u00e9ricas.<\/li>\n<li><strong>Portabilidad de la plataforma<\/strong>: una imagen de Docker creada en una computadora port\u00e1til puede ejecutarse en un cl\u00faster de HPC, una instancia en la nube o una estaci\u00f3n de trabajo de colega sin modificaciones.<\/li>\n<li><strong>Aislamiento<\/strong>: Las dependencias de simulaci\u00f3n no entran en conflicto con las bibliotecas del sistema u otros proyectos.<\/li>\n<li><strong>Instant\u00e1neas versionadas<\/strong>: cada imagen de Docker es inmutable y se puede etiquetar (por ejemplo, <code>my-sim:paper-v1<\/code>) para una reproducci\u00f3n futura exacta.<\/li>\n<\/ol>\n<h3>Limitaciones de Docker a considerar<\/h3>\n<p>A pesar de sus fortalezas, Docker tiene limitaciones importantes para la computaci\u00f3n cient\u00edfica:<\/p>\n<ul>\n<li><strong>No es una bala de plata<\/strong>: como se indica en \"Docker no garantiza la reproducibilidad\" (ARXIV 2026), los contenedores a\u00fan pueden mostrar un comportamiento no determinista si el hardware subyacente difiere (arquitectura de CPU, optimizaciones de punto flotante) o si servicios externos (base de datos, sistema de archivos) var\u00edan.<\/li>\n<li><strong>Dependencia del kernel<\/strong>: los contenedores de Docker comparten el kernel de host. Esto significa que el comportamiento del contenedor a\u00fan puede verse afectado por la versi\u00f3n y la configuraci\u00f3n del kernel del host.<\/li>\n<li><strong>Tama\u00f1o de sobrecarga<\/strong>: Las im\u00e1genes del sistema operativo completo pueden ser grandes (cientos de MB a GB), aunque las im\u00e1genes delgadas como <code>alpine<\/code> ayudan.<\/li>\n<li><strong>Restricciones de HPC<\/strong>: Muchos centros de HPC no permiten el Docker directamente debido a problemas de seguridad; Usan <strong>Singularity<\/strong> o <strong>apptainer<\/strong> en su lugar. Sin embargo, puede crear im\u00e1genes de singularidad a partir de im\u00e1genes de Docker, lo que convierte a Docker en una herramienta de desarrollo viable.<\/li>\n<\/ul>\n<h3>Escribir archivos Docker para proyectos de simulaci\u00f3n<\/h3>\n<p><strong>DockerFile<\/strong> define c\u00f3mo crear su contenedor. Siguiendo \"Diez reglas simples para escribir archivos Docker para la investigaci\u00f3n reproducible\" (N\u00fcst et al., 2020), las pr\u00e1cticas clave incluyen:<\/p>\n<pre><code class=\"language-dockerfile\"># Start from a minimal, pinned base image\nFROM ubuntu:22.04  # Pin exact version, not :latest\n\n# Set environment variables for reproducibility\nENV LANG=C.UTF-8\nENV LC_ALL=C.UTF-8\n\n# Install system dependencies in one layer to minimize cache issues\nRUN apt-get update &amp;&amp; apt-get install -y \n    python3 \n    python3-pip \n    libopenblas-dev \n    &amp;&amp; rm -rf \/var\/lib\/apt\/lists\/*\n\n# Create and set working directory\nWORKDIR \/simulation\n\n# Copy dependency specifications first (for better caching)\nCOPY requirements.txt environment.yml .\/\n\n# Install Python packages with pinned versions\nRUN pip install --no-cache-dir -r requirements.txt\n\n# Copy simulation code\nCOPY src\/ .\/src\/\nCOPY scripts\/ .\/scripts\/\nCOPY data\/ .\/data\/\n\n# Define entry point or command\nENTRYPOINT [\"python3\", \"scripts\/run_simulation.py\"]\n<\/code><\/pre>\n<p><strong>Regla de teclas<\/strong>: anclar expl\u00edcitamente todas las versiones: imagen base, paquetes de sistema operativo, paquetes de Python e incluso versi\u00f3n PIP. Use <code>requirements.txt<\/code> o <code>environment.yml<\/code> con versiones exactas (<code>package==1.2.3<\/code>, no <code>package&gt;=1.0<\/code>).<\/p>\n<h2>CONDA para la gesti\u00f3n del medio ambiente en investigaci\u00f3n<\/h2>\n<h3>Lo que proporciona Conda<\/h3>\n<p><strong>Conda<\/strong> es un administrador de paquetes y entornos multiplataforma que maneja no solo paquetes de Python, sino tambi\u00e9n dependencias que no son de Python (bibliotecas C\/C++, compiladores, MPI). Esto lo hace particularmente adecuado para la simulaci\u00f3n cient\u00edfica en la que es posible que necesite versiones espec\u00edficas de OpenMPi, FFTW o HDF5.<\/p>\n<p>Conda entrega:<\/p>\n<ol>\n<li><strong>Agn\u00f3stico de lenguaje<\/strong>: instale las bibliotecas Python, R, C\/C++ y las herramientas del sistema en un entorno.<\/li>\n<li><strong>Dependencias binarias<\/strong>: los paquetes precompilados evitan la compilaci\u00f3n del infierno en diferentes sistemas.<\/li>\n<li><strong>Entornos aislados<\/strong>: cada proyecto tiene su propio entorno sin contaminaci\u00f3n cruzada.<\/li>\n<li><strong>Exportar\/Importar<\/strong>: <code>conda env export &gt; environment.yml<\/code> Captura todo el entorno para una reproducci\u00f3n exacta.<\/li>\n<\/ol>\n<h3>Mejores pr\u00e1cticas de Conda<\/h3>\n<p>Basado en la gu\u00eda de MSI de la Universidad de Minnesota y Anaconda:<\/p>\n<ul>\n<li><strong>Nunca instale en <code>base<\/code><\/strong>: cree un nuevo entorno para cada proyecto: <pre><code class=\"language-bash\">conda create --name my-simulation python=3.11\nconda activate my-simulation\n<\/code><\/pre><\/li>\n<li><strong>Utilice los canales de la comunidad<\/strong>: prefiera <code>conda-forge<\/code> sobre los valores predeterminados para paquetes cient\u00edficos m\u00e1s actualizados: <pre><code class=\"language-bash\">conda config --add channels conda-forge\nconda config --set channel_priority strict\n<\/code><\/pre><\/li>\n<li><strong>Instalar todos los paquetes a la vez<\/strong>: Esto evita conflictos de dependencias: <pre><code class=\"language-bash\">conda install numpy scipy matplotlib fipy\n<\/code><\/pre><\/li>\n<li><strong>No modifique los entornos existentes<\/strong>: si necesita paquetes nuevos, actualice la especificaci\u00f3n del entorno o cree un entorno nuevo a partir del archivo YAML actualizado.<\/li>\n<li><strong>Exportar limpiamente<\/strong>: al compartir, elimine paquetes espec\u00edficos de la plataforma y elementos instalados por PIP que no son esenciales: <pre><code class=\"language-bash\">conda env export --no-builds | grep -v \"prefix:\" &gt; environment.yml\n<\/code><\/pre><\/li>\n<\/ul>\n<h2>Docker vs Conda: cu\u00e1ndo elegir cu\u00e1l<\/h2>\n<p>La pregunta no es \"\u00bfDocker o Conda?\": resuelven diferentes problemas y son <strong>complementarios<\/strong>.<\/p>\n<table>\n<thead>\n<tr>\n<th>Aspecto<\/th>\n<th>Estibador<\/th>\n<th>condaci\u00f3n<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><strong>\u00c1mbito<\/strong><\/td>\n<td>Sistema operativo completo + tiempo de ejecuci\u00f3n<\/td>\n<td>Paquete y Amp; Gerente de Ambiente<\/td>\n<\/tr>\n<tr>\n<td><strong>aislamiento<\/strong><\/td>\n<td>Nivel de sistema (espacio de nombres del kernel)<\/td>\n<td>Entorno de espacio de usuario<\/td>\n<\/tr>\n<tr>\n<td><strong>Tama\u00f1o<\/strong><\/td>\n<td>Grande (100 MB\u20131 GB+)<\/td>\n<td>Peque\u00f1o (MBS)<\/td>\n<\/tr>\n<tr>\n<td><strong>velocidad<\/strong><\/td>\n<td>M\u00e1s lento para construir\/transferir<\/td>\n<td>Activaci\u00f3n instant\u00e1nea<\/td>\n<\/tr>\n<tr>\n<td><strong>Soporte HPC<\/strong><\/td>\n<td>Limitado (funciona la singularidad)<\/td>\n<td>Excelente (nativo)<\/td>\n<\/tr>\n<tr>\n<td><strong>Caso de uso<\/strong><\/td>\n<td>Publicar, compartir, despliegue<\/td>\n<td>Desarrollo diario, exploraci\u00f3n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h3>Recomendaci\u00f3n pr\u00e1ctica<\/h3>\n<ul>\n<li><strong>Utilice conda para el desarrollo<\/strong>: cree r\u00e1pidamente entornos aislados, pruebe las dependencias e iterar\u00e1 en el c\u00f3digo. Es ligero y r\u00e1pido.<\/li>\n<li><strong>Utilice Docker para la conservaci\u00f3n<\/strong>: una vez que su simulaci\u00f3n funcione, cree una imagen de Docker para \"congelar\" el entorno exacto. Comparta esta imagen con colaboradores, adj\u00fantela a publicaciones o \u00fasela para CI\/CD.<\/li>\n<li><strong>Combine ambos<\/strong>: desarrolle en conda, luego cree un dockerfile que: <ul> <li>copia el entorno de conda en la imagen, o<\/li> <li>recrea el entorno utilizando <code>environment.yml<\/code><\/li> <\/ul><\/li>\n<\/ul>\n<p>Este enfoque en capas le brinda agilidad de desarrollo y robustez de publicaci\u00f3n.<\/p>\n<h2>Integraci\u00f3n de Docker y Conda en flujos de trabajo cient\u00edficos<\/h2>\n<h3>Estrategia 1: Conda dentro de Docker<\/h3>\n<p>La integraci\u00f3n m\u00e1s com\u00fan es instalar y usar conda dentro de un contenedor docker. Esto le brinda la administraci\u00f3n de paquetes de gran tama\u00f1o de Conda dentro del aislamiento del sistema de Docker.<\/p>\n<pre><code class=\"language-dockerfile\">FROM ubuntu:22.04\n\n# Install Miniconda\nRUN wget https:\/\/repo.anaconda.com\/miniconda\/Miniconda3-latest-Linux-x86_64.sh \n    &amp;&amp; bash Miniconda3-latest-Linux-x86_64.sh -b -p \/opt\/conda \n    &amp;&amp; rm Miniconda3-latest-Linux-x86_64.sh\nENV PATH=\/opt\/conda\/bin:$PATH\n\n# Create and use a conda environment\nCOPY environment.yml .\nRUN conda env create -f environment.yml\nENV PATH=\/opt\/conda\/envs\/my-sim\/bin:$PATH\n<\/code><\/pre>\n<p><strong>Pros<\/strong>: Aprovecha el extenso ecosistema de paquetes cient\u00edficos de CONDA; consistente con los flujos de trabajo de desarrollo local.<br> <strong>cons<\/strong>: tama\u00f1o de imagen m\u00e1s grande; Matices de activaci\u00f3n de conda en Docker.<\/p>\n<h3>Estrategia 2: Docker para la captura del entorno<\/h3>\n<p>Desarrolle localmente con Conda, luego exporte el entorno y hornee en una imagen de Docker sin ejecutar Conda en tiempo de ejecuci\u00f3n:<\/p>\n<pre><code class=\"language-dockerfile\">FROM python:3.11-slim\n\n# Copy pre-built packages or use pip from a frozen requirements.txt\nCOPY requirements.txt .\nRUN pip install --no-cache-dir -r requirements.txt\n<\/code><\/pre>\n<p>Esto es m\u00e1s simple pero pierde el manejo de dependencias que no son de Python de Conda.<\/p>\n<h3>Estrategia 3: Construcciones de varias etapas para HPC<\/h3>\n<p>Para los cl\u00fasteres de HPC que usan Singularity, cree la imagen de Docker localmente y luego convi\u00e9rtala en singularidad:<\/p>\n<pre><code class=\"language-bash\">docker build -t my-sim:latest .\nsingularity build my-sim.sif docker:\/\/my-sim:latest\n<\/code><\/pre>\n<p>Este flujo de trabajo le permite desarrollar con Docker (Easy Testing) e implementar en HPC (Singularity).<\/p>\n<h2>Trampas comunes y c\u00f3mo evitarlas<\/h2>\n<p>Bas\u00e1ndose en el an\u00e1lisis de los desaf\u00edos de reproducibilidad en la investigaci\u00f3n de simulaci\u00f3n, aqu\u00ed hay errores cr\u00edticos a evitar:<\/p>\n<h3>1. <strong>Documentaci\u00f3n desaparecida o incompleta<\/strong><\/h3>\n<p><strong>Problema<\/strong>: tiene una imagen de Docker que funciona, pero no tiene registro de c\u00f3mo usarla, qu\u00e9 entradas espera o c\u00f3mo interpretar las salidas.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>: incluye un <code>README.md<\/code> en el contenedor (o junto a la imagen) con:<\/p>\n<ul>\n<li>C\u00f3mo ejecutar la simulaci\u00f3n (argumentos de l\u00ednea de comandos)<\/li>\n<li>Formatos de archivo de entrada esperados<\/li>\n<li>Descripciones de archivos de salida<\/li>\n<li>Requisitos de hardware (CPU, memoria, GPU)<\/li>\n<li>Limitaciones conocidas<\/li>\n<\/ul>\n<h3>2. <strong>Dependencias no ancladas<\/strong><\/h3>\n<p><strong>Problema<\/strong>: El uso de <code>numpy&gt;=1.0<\/code> o <code>python=3.x<\/code> permite actualizaciones autom\u00e1ticas que pueden cambiar el comportamiento.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>: PIN Versiones exactas en <code>environment.yml<\/code> y <code>requirements.txt<\/code>:<\/p>\n<pre><code class=\"language-yaml\">dependencies:\n  - python=3.11.8\n  - numpy=1.26.4\n  - scipy=1.11.4\n  - pip:\n    - my-package==0.3.2\n<\/code><\/pre>\n<h3>3. <strong>Simulaciones no deterministas<\/strong><\/h3>\n<p><strong>Problema<\/strong>: incluso con entornos id\u00e9nticos, las simulaciones producen resultados ligeramente diferentes debido a la no asociatividad de punto flotante, las condiciones de carrera paralelas o la memoria no inicializada.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>:<\/p>\n<ul>\n<li>Establezca banderas deterministas donde est\u00e9 disponible (por ejemplo, OpenMP <code>OMP_NUM_THREADS=1<\/code>, enhebrado blas)<\/li>\n<li>Use semillas aleatorias fijas y docum\u00e9ntelas<\/li>\n<li>Pruebe la reproducibilidad ejecutando el contenedor varias veces en el mismo host<\/li>\n<\/ul>\n<h3>4. <strong>Grandes datos dentro de contenedores<\/strong><\/h3>\n<p><strong>Problema<\/strong>: hornear grandes conjuntos de datos de simulaci\u00f3n en im\u00e1genes de Docker los infla y hace que la distribuci\u00f3n sea lenta.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>: Mantenga los datos externos. Utilice los vol\u00famenes de Docker o los montajes de enlace para adjuntar datos en tiempo de ejecuci\u00f3n:<\/p>\n<pre><code class=\"language-bash\">docker run -v \/path\/to\/data:\/data my-sim:latest\n<\/code><\/pre>\n<p>Documente las expectativas de los datos claramente.<\/p>\n<h3>5. <strong>Ignorar las restricciones de HPC<\/strong><\/h3>\n<p><strong>Problema<\/strong>: las im\u00e1genes de Docker que funcionan en una computadora port\u00e1til fallan en un cl\u00faster de HPC debido a que faltan implementaciones de MPI, controladores incompatibles o restricciones de seguridad.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>:<\/p>\n<ul>\n<li>Pruebe en un entorno similar a un cl\u00faster temprano<\/li>\n<li>Usar compatibilidad de singularidad al dirigirse a HPC<\/li>\n<li>Evite los patrones de Docker-in-Docker; Construya sobre una imagen base que coincida con el sistema operativo de cl\u00faster (por ejemplo, CentOS\/Rocky si el cl\u00faster usa esos)<\/li>\n<\/ul>\n<h3>6. <strong>No hay control de versiones para archivos de Dockerfiles y de entorno<\/strong><\/h3>\n<p><strong>Problema<\/strong>: tiene una imagen de trabajo pero no tiene historial de cambios en el archivo dockerfile o <code>environment.yml<\/code>.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>: Trate las especificaciones de Dockerfile y Environment como <strong>c\u00f3digo<\/strong>. Gu\u00e1rdelos en Git junto con su c\u00f3digo de simulaci\u00f3n. Liberaciones de etiquetas (por ejemplo, <code>git tag -a v1.0 -m \"Paper submission\"<\/code>).<\/p>\n<h3>7. <strong>Con vistas a los servicios externos<\/strong><\/h3>\n<p><strong>Problema<\/strong>: su simulaci\u00f3n extrae datos de una base de datos o API que cambia con el tiempo, rompiendo la reproducibilidad.<\/p>\n<p><strong>Soluci\u00f3n<\/strong>: O bien:<\/p>\n<ul>\n<li>Snapshot datos externos e incl\u00fayalos en su repositorio o contenedor, o<\/li>\n<li>Use puntos finales de API versionados y documente la versi\u00f3n\/fecha exacta a la que se accede<\/li>\n<\/ul>\n<h2>Consideraciones de HPC y cl\u00faster<\/h2>\n<p>Los entornos inform\u00e1ticos de alto rendimiento introducen desaf\u00edos de reproducibilidad adicionales:<\/p>\n<h3>Singularity\/Aptainer en lugar de Docker<\/h3>\n<p>La mayor\u00eda de los centros de HPC proh\u00edben Docker por razones de seguridad. En cambio, proporcionan <strong>singularity<\/strong> (o su bifurcaci\u00f3n <strong>apptainer<\/strong>). Los contenedores de singularidad se construyen a partir de im\u00e1genes de Docker:<\/p>\n<pre><code class=\"language-bash\"># On your local machine with Docker\ndocker pull ubuntu:22.04\ndocker tag ubuntu:22.04 my-sim:base\n\n# Build your image as usual\ndocker build -t my-sim:latest .\n\n# Transfer image to HPC and convert\nsingularity build my-sim.sif docker:\/\/my-sim:latest\n<\/code><\/pre>\n<p><strong>Diferencia clave<\/strong>: Singularity ejecuta contenedores como el usuario invocador (sin root), por lo que las rutas de instalaci\u00f3n del paquete difieren. Pruebe su Dockerfile con singularidad para detectar problemas temprano.<\/p>\n<h3>Sistemas de m\u00f3dulos<\/h3>\n<p>Muchos cl\u00fasteres de HPC utilizan <strong>M\u00f3dulos de entorno<\/strong> (LMOD) para administrar las versiones de software. Puedes:<\/p>\n<ul>\n<li>Cargue los m\u00f3dulos necesarios antes de ejecutar su contenedor (si la singularidad puede acceder a ellos), o<\/li>\n<li>Construya su contenedor en una imagen base que ya incluya las bibliotecas necesarias<\/li>\n<\/ul>\n<h3>E\/S en paralelo y MPI<\/h3>\n<p>Si su simulaci\u00f3n utiliza MPI (interfaz de paso de mensajes), aseg\u00farese de que su contenedor incluya una implementaci\u00f3n MPI compatible. Para singularidad, puede <strong>bind-mount<\/strong> las bibliotecas MPI del host:<\/p>\n<pre><code class=\"language-bash\">singularity run --nv -B \/usr\/lib\/x86_64-linux-gnu\/openmpi:\/usr\/lib\/x86_64-linux-gnu\/openmpi my-sim.sif\n<\/code><\/pre>\n<p>Alternativamente, instale MPich o OpenMPi dentro del contenedor y aseg\u00farese de que est\u00e9 configurado para usar la estructura de red del host (InfiniBand, etc.).<\/p>\n<h3>Soporte de GPU<\/h3>\n<p>Para las simulaciones aceleradas por GPU, tanto Docker como Singularity requieren banderas especiales:<\/p>\n<ul>\n<li>Docker: <code>--gpus all<\/code><\/li>\n<li>Singularidad: <code>--nv<\/code><\/li>\n<\/ul>\n<p>Pruebe la funcionalidad de la GPU a fondo en su contenedor.<\/p>\n<h2>Gu\u00eda de implementaci\u00f3n paso a paso<\/h2>\n<p>Aqu\u00ed hay un flujo de trabajo pr\u00e1ctico para implementar flujos de trabajo de investigaci\u00f3n reproducibles en su proyecto de simulaci\u00f3n:<\/p>\n<h3>Fase 1: Configuraci\u00f3n del proyecto<\/h3>\n<ol>\n<li><strong>Control de versi\u00f3n inicial<\/strong> (git): <pre><code class=\"language-bash\">git init\ngit add .\ngit commit -m \"Initial project structure\"\n<\/code><\/pre><\/li>\n<li><strong>Crear entorno de conda<\/strong>: <pre><code class=\"language-bash\">conda create --name my-sim python=3.11\nconda activate my-sim\n<\/code><\/pre><\/li>\n<li><strong>Instalar dependencias<\/strong> y registrarlas: <pre><code class=\"language-bash\">conda install numpy scipy matplotlib fipy  # Example for PDE simulations\nconda env export --no-builds | grep -v \"prefix:\" &gt; environment.yml\n<\/code><\/pre><\/li>\n<li><strong>Crear estructura de proyecto<\/strong>: <pre><code>my-simulation\/\n\u251c\u2500\u2500 src\/              # Source code\n\u251c\u2500\u2500 scripts\/          # Run scripts, entry points\n\u251c\u2500\u2500 data\/             # Input data (git-ignored if large)\n\u251c\u2500\u2500 outputs\/          # Generated results (git-ignored)\n\u251c\u2500\u2500 docs\/             # Documentation\n\u251c\u2500\u2500 environment.yml   # Conda environment\n\u251c\u2500\u2500 requirements.txt  # Pip-only dependencies (if any)\n\u251c\u2500\u2500 Dockerfile        # Container definition\n\u251c\u2500\u2500 README.md         # Usage instructions\n\u2514\u2500\u2500 .gitignore        # Exclude outputs, large data\n<\/code><\/pre><\/li>\n<\/ol>\n<h3>Fase 2: Desarrollo con Conda<\/h3>\n<ul>\n<li>Desarrollar y probar dentro del entorno CONDA<\/li>\n<li>Confirmar cambios de c\u00f3digo con frecuencia<\/li>\n<li>Actualizar <code>environment.yml<\/code> al agregar\/eliminar paquetes<\/li>\n<li>Use <code>.gitignore<\/code> para excluir salidas generadas y archivos de datos grandes<\/li>\n<\/ul>\n<h3>Fase 3: Construyendo la imagen de Docker<\/h3>\n<ol>\n<li><strong>Crear un archivo docker<\/strong> (ver ejemplo arriba)<\/li>\n<li><strong>Construye la imagen<\/strong>: <pre><code class=\"language-bash\">docker build -t my-sim:latest .\n<\/code><\/pre><\/li>\n<li><strong>Prueba el contenedor<\/strong>: <pre><code class=\"language-bash\">docker run -v $(pwd)\/data:\/data my-sim:latest python scripts\/run_simulation.py --input \/data\/input.h5\n<\/code><\/pre><\/li>\n<li><strong>Tag para publicaci\u00f3n<\/strong>: <pre><code class=\"language-bash\">docker tag my-sim:latest my-sim:paper-v1.0\n<\/code><\/pre><\/li>\n<li><strong>Pulse al registro<\/strong> (opcional, para compartir): <pre><code class=\"language-bash\">docker push my-registry.example.com\/my-sim:paper-v1.0\n<\/code><\/pre><\/li>\n<\/ol>\n<h3>Fase 4: Verificaci\u00f3n y Compartir<\/h3>\n<ol>\n<li><strong>Reproducibilidad de prueba<\/strong>: haga que un colega tire y ejecute la imagen. Deben obtener resultados id\u00e9nticos (bit por bit id\u00e9ntico si la simulaci\u00f3n es determinista).<\/li>\n<li><strong>Documento<\/strong>: Asegure <code>README.md<\/code> Incluye: <ul> <li>C\u00f3mo obtener la imagen (Docker Hub, Registro o <code>.sif<\/code> Archivo)<\/li> <li>C\u00f3mo ejecutarla (Comando completo)<\/li> <li> Especificaciones del archivo de entrada<\/li> <li>Archivos de salida esperados y sus formatos<\/li> <li>Informaci\u00f3n de citas<\/li> <\/ul><\/li>\n<li><strong>Archivo<\/strong>: Deposite la imagen de Docker (o Singularity <code>.sif<\/code>) en un archivo a largo plazo como Zenodo o FigShare, e incluya el enlace en los m\u00e9todos de su documento o en la declaraci\u00f3n de disponibilidad de datos.<\/li>\n<\/ol>\n<h3>Fase 5: Mantenimiento a largo plazo<\/h3>\n<ul>\n<li>Al realizar cambios de c\u00f3digo, actualice la imagen de Docker y la etiqueta con una nueva versi\u00f3n (por ejemplo, <code>v1.1<\/code>)<\/li>\n<li>Mantenga im\u00e1genes\/etiquetas antiguas durante el tiempo que necesite reproducir resultados antiguos<\/li>\n<li>Use etiquetas Git para correlacionar confirmaciones de c\u00f3digo con versiones de imagen de Docker<\/li>\n<\/ul>\n<h2>Conclusi\u00f3n y pr\u00f3ximos pasos<\/h2>\n<p>La implementaci\u00f3n de flujos de trabajo de investigaci\u00f3n reproducibles no es una decisi\u00f3n de herramienta \u00fanica, es una <strong>estrategia en capas<\/strong>:<\/p>\n<ul>\n<li><strong>Conda<\/strong> para una gesti\u00f3n del entorno ligero y r\u00e1pido durante el desarrollo<\/li>\n<li><strong>Docker<\/strong> para instant\u00e1neas inmutables y port\u00e1tiles, adecuadas para la publicaci\u00f3n y la colaboraci\u00f3n<\/li>\n<li><strong>Git<\/strong> para el control de versiones de c\u00f3digo, dockerfiles y especificaciones de entorno<\/li>\n<li><strong>Documentaci\u00f3n<\/strong> para que el flujo de trabajo sea comprensible y utilizable por otros<\/li>\n<\/ul>\n<p>Para proyectos de simulaci\u00f3n donde la correcci\u00f3n y la verificabilidad son primordiales, esta combinaci\u00f3n proporciona una base s\u00f3lida. Comience con Conda para su pr\u00f3ximo proyecto, y una vez que la simulaci\u00f3n est\u00e9 funcionando, invierta el tiempo para crear una imagen de Docker. El costo inicial paga dividendos cuando usted (u otros) necesitan volver a ejecutar la simulaci\u00f3n meses o a\u00f1os despu\u00e9s con confianza.<\/p>\n<p><strong>Siguiente pasos que puedes tomar hoy:<\/strong><\/p>\n<ol>\n<li>Auditar sus proyectos de simulaci\u00f3n actuales: \u00bfEst\u00e1n documentados los entornos? \u00bfSe fijan las dependencias?<\/li>\n<li>Convierta un proyecto existente para utilizar entornos CONDA con <code>environment.yml<\/code><\/li>\n<li>Cree una imagen de Docker para una simulaci\u00f3n de trabajo y pru\u00e9bela en una m\u00e1quina diferente<\/li>\n<li>Explore las pol\u00edticas de singularidad de su centro de HPC y convierta una imagen de Docker a formato de singularidad<\/li>\n<li>Incluya especificaciones de entorno e im\u00e1genes de contenedores en los materiales complementarios de su pr\u00f3ximo documento<\/li>\n<\/ol>\n<h2>Gu\u00edas relacionadas<\/h2>\n<ul>\n<li><a href=\"\/managing-research-software-through-tickets\">administrar software de investigaci\u00f3n a trav\u00e9s de tickets<\/a> \u2013 Reproducibilidad de estructuras Trabajo como seguimiento de problemas y mejoras<\/li>\n<li><a href=\"\/managing-large-scale-pde-problems-strategies-solvers-and-hpc-case-studies\">Gesti\u00f3n de problemas de PDE a gran escala: estrategias, solucionadores y estudios de casos de HPC<\/a> \u2013 Escala sus simulaciones Mientras mantiene la reproducibilidad<\/li>\n<li><a href=\"\/tracking-long-term-technical-debt-in-research-software\">seguimiento de la deuda t\u00e9cnica en el software de investigaci\u00f3n<\/a>: use pr\u00e1cticas de CI\/CD para mantener la reproducibilidad a lo largo del tiempo<\/li>\n<li><a href=\"\/collaboration-between-developers-and-researchers-turning-innovation-into-scalable-impact\">Colaboraci\u00f3n entre desarrolladores e investigadores<\/a> \u2013 Asegurar la reproducibilidad a trav\u00e9s de los l\u00edmites del equipo<\/li>\n<\/ul>\n<h2>Referencias y lectura adicional<\/h2>\n<ul>\n<li>Boettiger, C. (2015). <a href=\"https:\/\/doi.org\/10.1145\/2723872.2723882\">Una introducci\u00f3n a Docker para la investigaci\u00f3n reproducible<\/a>. <em>Revisi\u00f3n de sistemas operativos ACM SIGOPS<\/em>.<\/li>\n<li>N\u00fcst, D., et al. (2020). <a href=\"https:\/\/doi.org\/10.1371\/journal.pcbi.1008319\">Diez reglas simples para escribir Dockerfiles para la ciencia de datos reproducibles<\/a>. <em>PLOS Biolog\u00eda computacional<\/em>.<\/li>\n<li>El Camino de Turing. <a href=\"https:\/\/book.the-turing-way.org\/reproducible-research\/overview\/overview-definitions\/\">definiciones de investigaci\u00f3n reproducible<\/a>.<\/li>\n<li>Fitzpatrick, B. G., et al. (2018). <a href=\"https:\/\/doi.org\/10.3389\/fcomp.2018.00001\">Problemas en la investigaci\u00f3n de simulaci\u00f3n reproducible<\/a>. <em>Fronteras en Ciencias de la Computaci\u00f3n<\/em>.<\/li>\n<li>Documentaci\u00f3n de Conda. <a href=\"https:\/\/docs.conda.io\/projects\/conda\/en\/stable\/user-guide\/tasks\/manage-environments.html\">administraci\u00f3n de entornos<\/a>.<\/li>\n<\/ul>\n"},"excerpt":{"rendered":"<p><span class=\"span-reading-time rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Reading Time: <\/span> <span class=\"rt-time\"> 11<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span>Los flujos de trabajo de investigaci\u00f3n reproducibles garantizan que los resultados de la simulaci\u00f3n puedan ser creados exactamente por otros (o su futuro yo) utilizando los mismos datos, c\u00f3digo y entorno computacional. Docker Proporciona una completa contenedorizaci\u00f3n a nivel de sistema para una m\u00e1xima coherencia en todas las plataformas, mientras que conda ofrece una gesti\u00f3n [&hellip;]<\/p>\n","protected":false,"raw":""},"author":3,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_locale":"es_ES","_original_post":"https:\/\/matforge.org\/?p=199","iawp_total_views":0,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-601","post","type-post","status-publish","format-standard","hentry","category-simulation-modeling-projects","es-ES"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.1 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Flujos de trabajo de investigaci\u00f3n reproducibles: Docker y Conda para proyectos de simulaci\u00f3n - matforge.org<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/\" \/>\n<meta property=\"og:locale\" content=\"es_ES\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Flujos de trabajo de investigaci\u00f3n reproducibles: Docker y Conda para proyectos de simulaci\u00f3n - matforge.org\" \/>\n<meta property=\"og:description\" content=\"Reading Time:  11 minutesLos flujos de trabajo de investigaci\u00f3n reproducibles garantizan que los resultados de la simulaci\u00f3n puedan ser creados exactamente por otros (o su futuro yo) utilizando los mismos datos, c\u00f3digo y entorno computacional. Docker Proporciona una completa contenedorizaci\u00f3n a nivel de sistema para una m\u00e1xima coherencia en todas las plataformas, mientras que conda ofrece una gesti\u00f3n [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/\" \/>\n<meta property=\"og:site_name\" content=\"matforge.org\" \/>\n<meta property=\"article:published_time\" content=\"2026-07-22T08:16:55+00:00\" \/>\n<meta name=\"author\" content=\"Tomas Delgado\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Escrito por\" \/>\n\t<meta name=\"twitter:data1\" content=\"Tomas Delgado\" \/>\n\t<meta name=\"twitter:label2\" content=\"Tiempo de lectura\" \/>\n\t<meta name=\"twitter:data2\" content=\"18 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/\"},\"author\":{\"name\":\"Tomas Delgado\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/518cdd1f18dd092f4ed738d68e540061\"},\"headline\":\"Flujos de trabajo de investigaci\u00f3n reproducibles: Docker y Conda para proyectos de simulaci\u00f3n\",\"datePublished\":\"2026-07-22T08:16:55+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/\"},\"wordCount\":3048,\"commentCount\":0,\"articleSection\":[\"Simulaci\u00f3n &amp; Proyectos de modelado\"],\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/matforge.org\\\/es\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/\",\"url\":\"https:\\\/\\\/matforge.org\\\/es\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/\",\"name\":\"Flujos de trabajo de investigaci\u00f3n reproducibles: Docker y Conda para proyectos de simulaci\u00f3n - matforge.org\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#website\"},\"datePublished\":\"2026-07-22T08:16:55+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/518cdd1f18dd092f4ed738d68e540061\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/#breadcrumb\"},\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/matforge.org\\\/es\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/matforge.org\\\/es\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Flujos de trabajo de investigaci\u00f3n reproducibles: Docker y Conda para proyectos de simulaci\u00f3n\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#website\",\"url\":\"https:\\\/\\\/matforge.org\\\/\",\"name\":\"matforge.org\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/matforge.org\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"es\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/518cdd1f18dd092f4ed738d68e540061\",\"name\":\"Tomas Delgado\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/202f82c9f4f4534a3ba77bf8a8fbef09cf8489f52bdf819082f21390da4e7c9a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/202f82c9f4f4534a3ba77bf8a8fbef09cf8489f52bdf819082f21390da4e7c9a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/202f82c9f4f4534a3ba77bf8a8fbef09cf8489f52bdf819082f21390da4e7c9a?s=96&d=mm&r=g\",\"caption\":\"Tomas Delgado\"},\"sameAs\":[\"http:\\\/\\\/matforge.org\"],\"url\":\"https:\\\/\\\/matforge.org\\\/author\\\/tomas-delgado\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Flujos de trabajo de investigaci\u00f3n reproducibles: Docker y Conda para proyectos de simulaci\u00f3n - matforge.org","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/","og_locale":"es_ES","og_type":"article","og_title":"Flujos de trabajo de investigaci\u00f3n reproducibles: Docker y Conda para proyectos de simulaci\u00f3n - matforge.org","og_description":"Reading Time:  11 minutesLos flujos de trabajo de investigaci\u00f3n reproducibles garantizan que los resultados de la simulaci\u00f3n puedan ser creados exactamente por otros (o su futuro yo) utilizando los mismos datos, c\u00f3digo y entorno computacional. Docker Proporciona una completa contenedorizaci\u00f3n a nivel de sistema para una m\u00e1xima coherencia en todas las plataformas, mientras que conda ofrece una gesti\u00f3n [&hellip;]","og_url":"https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/","og_site_name":"matforge.org","article_published_time":"2026-07-22T08:16:55+00:00","author":"Tomas Delgado","twitter_card":"summary_large_image","twitter_misc":{"Escrito por":"Tomas Delgado","Tiempo de lectura":"18 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/#article","isPartOf":{"@id":"https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/"},"author":{"name":"Tomas Delgado","@id":"https:\/\/matforge.org\/#\/schema\/person\/518cdd1f18dd092f4ed738d68e540061"},"headline":"Flujos de trabajo de investigaci\u00f3n reproducibles: Docker y Conda para proyectos de simulaci\u00f3n","datePublished":"2026-07-22T08:16:55+00:00","mainEntityOfPage":{"@id":"https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/"},"wordCount":3048,"commentCount":0,"articleSection":["Simulaci\u00f3n &amp; Proyectos de modelado"],"inLanguage":"es","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/","url":"https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/","name":"Flujos de trabajo de investigaci\u00f3n reproducibles: Docker y Conda para proyectos de simulaci\u00f3n - matforge.org","isPartOf":{"@id":"https:\/\/matforge.org\/#website"},"datePublished":"2026-07-22T08:16:55+00:00","author":{"@id":"https:\/\/matforge.org\/#\/schema\/person\/518cdd1f18dd092f4ed738d68e540061"},"breadcrumb":{"@id":"https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/#breadcrumb"},"inLanguage":"es","potentialAction":[{"@type":"ReadAction","target":["https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/matforge.org\/es\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/matforge.org\/es\/"},{"@type":"ListItem","position":2,"name":"Flujos de trabajo de investigaci\u00f3n reproducibles: Docker y Conda para proyectos de simulaci\u00f3n"}]},{"@type":"WebSite","@id":"https:\/\/matforge.org\/#website","url":"https:\/\/matforge.org\/","name":"matforge.org","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/matforge.org\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"es"},{"@type":"Person","@id":"https:\/\/matforge.org\/#\/schema\/person\/518cdd1f18dd092f4ed738d68e540061","name":"Tomas Delgado","image":{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/secure.gravatar.com\/avatar\/202f82c9f4f4534a3ba77bf8a8fbef09cf8489f52bdf819082f21390da4e7c9a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/202f82c9f4f4534a3ba77bf8a8fbef09cf8489f52bdf819082f21390da4e7c9a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/202f82c9f4f4534a3ba77bf8a8fbef09cf8489f52bdf819082f21390da4e7c9a?s=96&d=mm&r=g","caption":"Tomas Delgado"},"sameAs":["http:\/\/matforge.org"],"url":"https:\/\/matforge.org\/author\/tomas-delgado\/"}]}},"_links":{"self":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/601","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/comments?post=601"}],"version-history":[{"count":1,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/601\/revisions"}],"predecessor-version":[{"id":688,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/601\/revisions\/688"}],"wp:attachment":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/media?parent=601"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/categories?post=601"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/tags?post=601"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}