{"id":848,"date":"2026-07-30T12:22:26","date_gmt":"2026-07-30T12:22:26","guid":{"rendered":"https:\/\/matforge.org\/?p=848","raw":"https:\/\/matforge.org\/?p=848"},"modified":"2026-07-30T12:22:26","modified_gmt":"2026-07-30T12:22:26","slug":"reproducible-research-workflows-docker-and-conda-for-simulation-projects","status":"publish","type":"post","link":"https:\/\/matforge.org\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/","title":{"rendered":"Reproduzierbare Forschungsworkflows: Docker und Conda f\u00fcr Simulationsprojekte","raw":"Reproduzierbare Forschungsworkflows: Docker und Conda f\u00fcr Simulationsprojekte"},"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\"> 9<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span><p>Reproduzierbare Recherche-Workflows stellen sicher, dass die Simulationsergebnisse von anderen (oder Ihrem zuk\u00fcnftigen Selbst) mithilfe derselben Daten-, Code- und Rechenumgebung exakt neu erstellt werden k\u00f6nnen. <strong>Docker<\/strong> Bietet eine vollst\u00e4ndige Containerisierung auf Systemebene f\u00fcr maximale Konsistenz \u00fcber Plattformen hinweg, w\u00e4hrend <strong>conda<\/strong> ein leichtes Paket- und Umgebungsmanagement bietet, das ideal f\u00fcr Python-basiertes wissenschaftliches Computing ist. F\u00fcr Simulationsprojekte empfehlen wir: (1) Conda f\u00fcr die t\u00e4gliche Entwicklung und Abh\u00e4ngigkeitsverwaltung, (2) Erstellen Sie Docker-Images, um Arbeitsumgebungen f\u00fcr die Ver\u00f6ffentlichung und Zusammenarbeit &#8222;einzufrieren&#8220; und (3) immer mit Versionskontrolle und gr\u00fcndlicher Dokumentation zu koppeln. Vermeiden Sie den h\u00e4ufigen Fehler, sich ausschlie\u00dflich auf ein Werkzeug zu verlassen &#8211; beides f\u00fcr eine robuste Reproduzierbarkeit zu kombinieren.<\/p>\n<h2>Einleitung: Die Reproduzierbarkeitsl\u00fccke in der Simulationsforschung<\/h2>\n<p>Wissenschaftliche Simulationsprojekte leiden oft unter einem stillen Ausfallmodus: Der Code hat gestern funktioniert, heute jedoch unterschiedliche Ergebnisse. Die zugrunde liegende Physik hat sich nicht ge\u00e4ndert &#8211; Ihre Rechenumgebung hat sich ge\u00e4ndert. Fehlende Paketversionen, ge\u00e4nderte Bibliotheksabh\u00e4ngigkeiten, Betriebssystemaktualisierungen oder sogar verschiedene Python-Interpreter k\u00f6nnen die Simulationsausgaben stillschweigend \u00e4ndern, manchmal auf schwer zu erkennende Weise.<\/p>\n<p>Dies ist mehr als eine Unannehmlichkeit. <strong>Reproduzierbarkeit<\/strong> ist der Eckpfeiler der kumulativen Wissenschaft &#8211; die F\u00e4higkeit anderer Forscher, Anspr\u00fcche zu \u00fcberpr\u00fcfen und auf Ihrer Arbeit aufzubauen. Wenn Simulationsergebnisse nicht zuverl\u00e4ssig wiederhergestellt werden k\u00f6nnen, erodiert Vertrauen, Papiere zur\u00fcckgezogen werden und wertvolle Forschungszeit verschwendet wird, um Umweltprobleme zu debuggen, anstatt Wissen zu erweitern.<\/p>\n<p>In diesem Handbuch werden wir untersuchen, wie reproduzierbare Forschungsworkflows f\u00fcr Simulationsprojekte mit <strong>docker<\/strong> und <strong>conda<\/strong> implementiert werden \u2013 zwei erg\u00e4nzende Tools, die zusammen eine robuste L\u00f6sung f\u00fcr die Konsistenz der Umgebung, das Abh\u00e4ngigkeitsmanagement und die langfristige Erhaltung von bieten Berechnungsmethoden.<\/p>\n<h2>Was ist reproduzierbare Forschung? Definitionen und Kernkomponenten<\/h2>\n<p>Im Kern bedeutet <strong>Reproduzierbare Forschung<\/strong>, dass ein unabh\u00e4ngiger Forscher die ver\u00f6ffentlichten Ergebnisse (Tabellen, Abbildungen, quantitative Ergebnisse) nur unter Verwendung der Originaldaten, des Codes und der Dokumentation regenerieren kann. Dies erfordert, wie durch den Turing-Weg definiert und in der Computerwissenschaft weit verbreitet ist, Folgendes erforderlich:<\/p>\n<ul>\n<li><strong>Datenverf\u00fcgbarkeit<\/strong>: Rohdaten sind zug\u00e4nglich (mit angemessenen Datenschutzhinweisen)<\/li>\n<li><strong>Codetransparenz<\/strong>: Alle Analyse- und Simulationsskripte werden gemeinsam genutzt<\/li>\n<li><strong>Dokumentation<\/strong>: Vollst\u00e4ndige Aufzeichnungen \u00fcber Softwareversionen, Parameter und Umgebungskonfigurationen<\/li>\n<li><strong>Umgebungskontrolle<\/strong>: Die genaue Laufzeitumgebung wird erfasst und rekonstruierbar<\/li>\n<\/ul>\n<p>Die Reproduzierbarkeit der Computer unterscheidet sich von der <strong>Replizabilit\u00e4t<\/strong> (\u00e4hnliche Schlussfolgerungen mit neuen Daten oder unabh\u00e4ngigen Methoden zu ziehen). Reproduzierbarkeit ist der Mindeststandard &#8211; es geht darum, dieselben Zahlen aus denselben Eingaben zu erhalten und die zugrunde liegenden wissenschaftlichen Behauptungen nicht zu validieren.<\/p>\n<blockquote>\n<p><strong>Warum es f\u00fcr Simulationsprojekte wichtig ist <\/strong>: PDE-Solver, Finite-Elemente-Methoden und andere Simulations-Frameworks umfassen h\u00e4ufig komplexe Abh\u00e4ngigkeitsketten. Eine geringf\u00fcgige Versions\u00e4nderung in einer numerischen Bibliothek kann das Diskretisierungsverhalten, die Konvergenzkriterien oder das Runden ver\u00e4ndern und messbar unterschiedliche Ergebnisse erzielen. Reproduzierbare Workflows beseitigen diese Quelle der Unsicherheit.<\/p>\n<\/blockquote>\n<h2>Docker f\u00fcr reproduzierbare wissenschaftliche Simulationen<\/h2>\n<h3>Was Docker bietet<\/h3>\n<p><strong>Docker<\/strong> ist eine Containerisierungsplattform, die eine Anwendung und ihre gesamte Laufzeitumgebung \u2013 Betriebssystem, Bibliotheken, Abh\u00e4ngigkeiten, Konfigurationsdateien \u2013 in ein tragbares, unver\u00e4nderliches Image packt. Wenn Sie einen Docker-Container ausf\u00fchren, f\u00fchren Sie genau dieselbe Umgebung aus, die unabh\u00e4ngig vom Hostsystem erstellt und getestet wurde.<\/p>\n<p>F\u00fcr Simulationsprojekte liefert Docker:<\/p>\n<ol>\n<li><strong>Umweltkonsistenz<\/strong>: &#8222;Es funktioniert auf meiner Maschine.&#8220; Der Container enth\u00e4lt bestimmte Versionen von Compilern, MPI-Implementierungen, Python-Interpreter und numerischen Bibliotheken.<\/li>\n<li><strong>Platform Portability<\/strong>: Ein Docker-Image, das auf einem Laptop erstellt wird, kann ohne \u00c4nderungen auf einem HPC-Cluster, einer Cloud-Instanz oder einer Workstation eines Kollegen ausgef\u00fchrt werden.<\/li>\n<li><strong>Isolation<\/strong>: Simulationsabh\u00e4ngigkeiten stehen nicht in Konflikt mit Systembibliotheken oder anderen Projekten.<\/li>\n<li><strong>Versions-Snapshots<\/strong>: Jedes Docker-Image ist unver\u00e4nderlich und kann f\u00fcr eine genaue zuk\u00fcnftige Wiedergabe markiert werden (z. B. <code>my-sim:paper-v1<\/code>).<\/li>\n<\/ol>\n<h3>Docker-Einschr\u00e4nkungen zu ber\u00fccksichtigen<\/h3>\n<p>Trotz seiner St\u00e4rken hat Docker wichtige Einschr\u00e4nkungen f\u00fcr das wissenschaftliche Rechnen:<\/p>\n<ul>\n<li><strong>Keine Silberkugel<\/strong>: Wie in &#8222;Docker \u00fcbernimmt keine Reproduzierbarkeit&#8220; (ArXiv 2026), k\u00f6nnen Container bei unterschiedlicher Hardware (CPU-Architektur, Gleitkommaoptimierungen) oder externen Services weiterhin nicht deterministisches Verhalten aufweisen. (Datenbank, Dateisystem) variieren.<\/li>\n<li><strong>Kernel-Abh\u00e4ngigkeit<\/strong>: Docker-Container teilen sich den Host-Kernel. Dies bedeutet, dass das Containerverhalten immer noch durch die Version und Konfiguration des Host-Kernels beeinflusst werden kann.<\/li>\n<li><strong>Gr\u00f6\u00dfe Overhead<\/strong>: Vollst\u00e4ndige OS-Bilder k\u00f6nnen gro\u00df sein (Hunderte von MB zu GB), obwohl schlanke Bilder wie <code>alpine<\/code> helfen.<\/li>\n<li><strong>HPC-Einschr\u00e4nkungen<\/strong>: Viele HPC-Zentren lassen Docker aufgrund von Sicherheitsbedenken nicht direkt zu. Sie verwenden stattdessen <strong>Singularity<\/strong> oder <strong>Apptainer<\/strong>. Sie k\u00f6nnen jedoch Singularity-Images aus Docker-Images erstellen, wodurch Docker zu einem tragf\u00e4higen Entwicklungswerkzeug wird.<\/li>\n<\/ul>\n<h3>Schreiben von DockerFiles f\u00fcr Simulationsprojekte<\/h3>\n<p>Die <strong>Dockerfile<\/strong> definiert, wie Sie Ihren Container erstellen. Nach den \u201eZehn einfachen Regeln f\u00fcr das Schreiben von Dockerfiles f\u00fcr reproduzierbare Forschung\u201c (N\u00fcst et al., 2020) sind die wichtigsten Praktiken:<\/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>Schl\u00fcsselregel<\/strong>: Alle Versionen explizit anheften \u2013 Basis-Image, OS-Pakete, Python-Pakete und sogar PIP-Version. Verwenden Sie <code>requirements.txt<\/code> oder <code>environment.yml<\/code> mit exakten Versionen (<code>package==1.2.3<\/code>, nicht <code>package&gt;=1.0<\/code>).<\/p>\n<h2>Conda f\u00fcr Umweltmanagement in der Forschung<\/h2>\n<h3>Was Conda bietet<\/h3>\n<p><strong>conda<\/strong> ist ein plattform\u00fcbergreifender Paket- und Umgebungsmanager, der nicht nur Python-Pakete, sondern auch Abh\u00e4ngigkeiten von Nicht-Python (C\/C++-Bibliotheken, Compiler, MPI) behandelt. Dies macht es besonders gut f\u00fcr wissenschaftliche Simulationen geeignet, wenn Sie m\u00f6glicherweise bestimmte Versionen von OpenMPI, FFTW oder HDF5 ben\u00f6tigen.<\/p>\n<p>Conda liefert:<\/p>\n<ol>\n<li><strong>Sprachagnostic<\/strong>: Installieren Sie Python, R, C\/C++ Bibliotheken und Systemtools in einer Umgebung.<\/li>\n<li><strong>Bin\u00e4re Abh\u00e4ngigkeiten<\/strong>: Vorkompilierte Pakete vermeiden die Kompilierung der H\u00f6lle auf verschiedenen Systemen.<\/li>\n<li><strong>Isolated Environments<\/strong>: Jedes Projekt erh\u00e4lt seine eigene Umgebung ohne Kreuzkontamination.<\/li>\n<li><strong>Export\/Import<\/strong>: <code>conda env export &gt; environment.yml<\/code> Erfasst die gesamte Umgebung f\u00fcr eine exakte Wiedergabe.<\/li>\n<\/ol>\n<h3>Best Practices von Conda<\/h3>\n<p>Basierend auf der MSI University of Minnesota und Anaconda Anleitung:<\/p>\n<ul>\n<li><strong>Niemals installieren in <code>base<\/code><\/strong>: Erstellen Sie f\u00fcr jedes Projekt eine neue Umgebung:\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>Community-Kan\u00e4le verwenden<\/strong>: Bevorzugen Sie <code>conda-forge<\/code> gegen\u00fcber Standardeinstellungen f\u00fcr aktuellere wissenschaftliche Pakete:\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>Alle Pakete auf einmal installieren<\/strong>: Dadurch werden Abh\u00e4ngigkeitskonflikte vermieden:\n<pre><code class=\"language-bash\">conda install numpy scipy matplotlib fipy\n<\/code><\/pre>\n<\/li>\n<li><strong>Bestehende Umgebungen nicht \u00e4ndern<\/strong>: Wenn Sie neue Pakete ben\u00f6tigen, aktualisieren Sie entweder die Umgebungsspezifikation oder erstellen Sie eine neue Umgebung aus der aktualisierten YAML-Datei.<\/li>\n<li><strong>Clean exportieren<\/strong>: Entfernen Sie beim Freigeben plattformspezifische Pakete und PIP-installierte Elemente, die nicht unbedingt erforderlich sind:\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: Wann w\u00e4hlen Sie welche<\/h2>\n<p>Die Frage lautet nicht &#8222;Docker oder Conda?&#8220; &#8211; Sie l\u00f6sen verschiedene Probleme und sind <strong>Erg\u00e4nzung <\/strong>.<\/p>\n<table>\n<thead>\n<tr>\n<th>Aspekt<\/th>\n<th>Docking<\/th>\n<th>Konda<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><strong>Scope<\/strong><\/td>\n<td>Gesamte Betriebssystem + Laufzeit<\/td>\n<td>Paket &amp; Umgebungsmanager<\/td>\n<\/tr>\n<tr>\n<td><strong>Isolierung<\/strong><\/td>\n<td>Systemebene (Kernel-Namespace)<\/td>\n<td>User-Space-Umgebung<\/td>\n<\/tr>\n<tr>\n<td><strong>Gr\u00f6\u00dfe<\/strong><\/td>\n<td>Gro\u00df (100 MB\u20131 GB+)<\/td>\n<td>Klein (MBS)<\/td>\n<\/tr>\n<tr>\n<td><strong>Geschwindigkeit<\/strong><\/td>\n<td>langsamer zu bauen \/ zu \u00fcbertragen<\/td>\n<td>Sofortige Aktivierung<\/td>\n<\/tr>\n<tr>\n<td><strong>HPC-Unterst\u00fctzung<\/strong><\/td>\n<td>Begrenzt (Singularit\u00e4t funktioniert)<\/td>\n<td>Ausgezeichnet (Native)<\/td>\n<\/tr>\n<tr>\n<td><strong> Anwendungsfall<\/strong><\/td>\n<td>Ver\u00f6ffentlichung, Freigabe, Bereitstellung<\/td>\n<td>T\u00e4gliche Entwicklung, Erkundung<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h3>Praktische Empfehlung<\/h3>\n<ul>\n<li><strong>CONDA f\u00fcr die Entwicklung verwenden<\/strong>: Erstellen Sie schnell isolierte Umgebungen, testen Sie Abh\u00e4ngigkeiten und iterieren Sie den Code. Es ist leicht und schnell.<\/li>\n<li><strong>Docker f\u00fcr die Erhaltung verwenden<\/strong>: Sobald Ihre Simulation funktioniert, erstellen Sie ein Docker-Image, um die genaue Umgebung zu &#8222;einfrieren&#8220;. Teilen Sie dieses Bild mit Mitarbeitern, h\u00e4ngen Sie es an Publikationen an oder verwenden Sie es f\u00fcr CI\/CD.<\/li>\n<li><strong>Kombinieren Sie beide<\/strong>: Entwickeln Sie in Conda und erstellen Sie dann eine Dockerdatei, die entweder:\n<ul>\n<li> die Conda-Umgebung in das Bild kopiert, oder <\/li>\n<li> die Umgebung mit den exportierten <code>environment.yml<\/code><\/li>\n<p> neu erstellt. <\/ul>\n<\/li>\n<\/ul>\n<p>Dieser geschichtete Ansatz gibt Ihnen Entwicklungsagilit\u00e4t und Publikations-Robustheit.<\/p>\n<h2>Integration von Docker und Conda in wissenschaftliche Workflows<\/h2>\n<h3>Strategie 1: Conda im Docker<\/h3>\n<p>Die h\u00e4ufigste Integration ist die Installation und Verwendung von Conda in einem Docker-Container. Dies gibt Ihnen die feink\u00f6rnige Paketverwaltung in Dockers Systemisolation.<\/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>: Nutzt das umfangreiche wissenschaftliche Paket-\u00d6kosystem von Conda; Konsistent mit lokalen Entwicklungs-Workflows.<br \/> <strong>cons<\/strong>: Gr\u00f6\u00dfere Bildgr\u00f6\u00dfe; Conda-Aktivierungsnuancen in Docker.<\/p>\n<h3>Strategie 2: Docker zur Umgebungserfassung<\/h3>\n<p>Entwickeln Sie lokal mit Conda, exportieren Sie die Umgebung und backen Sie sie in ein Docker-Image, ohne Conda zur Laufzeit auszuf\u00fchren:<\/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>Dies ist einfacher, verliert jedoch die Behandlung von Conda-Abh\u00e4ngigkeitsf\u00e4llen.<\/p>\n<h3>Strategie 3: Mehrstufige Builds f\u00fcr HPC<\/h3>\n<p>Erstellen Sie bei HPC-Clustern lokal das Docker-Image und konvertieren Sie es in Singularity:<\/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>Mit diesem Workflow k\u00f6nnen Sie sich mit Docker (Easy Testing) entwickeln und auf HPC (Singularity) bereitstellen.<\/p>\n<h2>H\u00e4ufige Fallstricke und wie man sie vermeidet<\/h2>\n<p>Basierend auf der Analyse der Reproduzierbarkeitsherausforderungen in der Simulationsforschung sind hier kritische Fehler zu vermeiden:<\/p>\n<h3>1. <strong>Fehlende oder unvollst\u00e4ndige Dokumentation<\/strong><\/h3>\n<p><strong>Problem<\/strong>: Sie haben ein funktionierendes Docker-Image, aber keine Aufzeichnung dar\u00fcber, wie es verwendet wird, welche Eingaben es erwartet oder wie Sie Ausgaben interpretieren.<\/p>\n<p><strong>L\u00f6sung<\/strong>: F\u00fcgen Sie <code>README.md<\/code> in den Beh\u00e4lter (oder neben dem Bild) ein mit:<\/p>\n<ul>\n<li>So f\u00fchren Sie die Simulation aus (Befehlszeilenargumente)<\/li>\n<li>Erwartete Eingabedateiformate<\/li>\n<li>Beschreibungen der Ausgabedatei<\/li>\n<li>Hardwareanforderungen (CPU, Speicher, GPU)<\/li>\n<li>Bekannte Einschr\u00e4nkungen<\/li>\n<\/ul>\n<h3>2. <strong>Unpinnende Abh\u00e4ngigkeiten<\/strong><\/h3>\n<p><strong>Problem<\/strong>: Verwenden von <code>numpy&gt;=1.0<\/code> oder <code>python=3.x<\/code> Erm\u00f6glicht automatische Updates, die das Verhalten \u00e4ndern k\u00f6nnen.<\/p>\n<p><strong>L\u00f6sung<\/strong>: Pin exakte Versionen in <code>environment.yml<\/code> und <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> Nicht-deterministische Simulationen <\/strong><\/h3>\n<p><strong>Problem<\/strong>: Selbst bei identischen Umgebungen f\u00fchren Simulationen aufgrund von Gleitkomma-Nicht-Assoziativit\u00e4t, parallelen Rassenbedingungen oder nicht initialisiertem Ged\u00e4chtnis zu leicht unterschiedlichen Ergebnissen.<\/p>\n<p><strong>L\u00f6sung<\/strong>:<\/p>\n<ul>\n<li>Setzen Sie deterministische Flags, sofern verf\u00fcgbar (z. B. OpenMP <code>OMP_NUM_THREADS=1<\/code>, BLAS-Gewinde<\/li>\n<li>Verwenden Sie feste zuf\u00e4llige Samen und dokumentieren Sie sie<\/li>\n<li>Testen Sie die Reproduzierbarkeit, indem Sie den Container mehrmals auf demselben Host ausf\u00fchren<\/li>\n<\/ul>\n<h3>4. <strong>Gro\u00dfe Daten in Containern<\/strong><\/h3>\n<p><strong>Problem<\/strong>: Das Backen gro\u00dfer Simulationsdatens\u00e4tze in Docker-Images bl\u00e4ht sie auf und verlangsamt die Verteilung.<\/p>\n<p><strong>L\u00f6sung<\/strong>: Halten Sie die Daten extern. Verwenden Sie Docker-Volumes oder Bindungs-Mounts, um Daten zur Laufzeit anzuh\u00e4ngen:<\/p>\n<pre><code class=\"language-bash\">docker run -v \/path\/to\/data:\/data my-sim:latest\n<\/code><\/pre>\n<p>Datenerwartungen klar dokumentieren.<\/p>\n<h3>5. <strong>HPC-Einschr\u00e4nkungen ignorieren<\/strong><\/h3>\n<p><strong>Problem<\/strong>: Docker-Images, die auf einem Laptop funktionieren, scheitern in einem HPC-Cluster aufgrund fehlender MPI-Implementierungen, inkompatibler Treiber oder Sicherheitsbeschr\u00e4nkungen.<\/p>\n<p><strong>L\u00f6sung<\/strong>:<\/p>\n<ul>\n<li>Testen Sie fr\u00fchzeitig in einer Cluster-\u00e4hnlichen Umgebung<\/li>\n<li>Verwenden Sie die Singularit\u00e4tskompatibilit\u00e4t, wenn Sie auf HPC abzielen<\/li>\n<li>Vermeiden Sie Docker-in-Docking-Muster. Bauen Sie auf einem Basis-Image auf, das dem Cluster-OS entspricht (z. B. CentOS \/ Rocky, wenn Cluster diese verwendet).<\/li>\n<\/ul>\n<h3>6. <strong>Keine Versionskontrolle f\u00fcr Dockerfiles und Umgebungsdateien<\/strong><\/h3>\n<p><strong>Problem<\/strong>: Sie haben ein Arbeitsbild, aber keine \u00c4nderungen an der Dockerfile oder <code>environment.yml<\/code>.<\/p>\n<p><strong>L\u00f6sung<\/strong>: Behandeln Sie Dockerfile- und Umgebungsspezifikationen als <strong>Code<\/strong>. Speichern Sie sie in Git neben Ihrem Simulationscode. Tag-Releases (z. B. <code>git tag -a v1.0 -m \"Paper submission\"<\/code>).<\/p>\n<h3>7. <strong>\u00dcberblickende externe Dienste<\/strong><\/h3>\n<p><strong>Problem<\/strong>: Ihre Simulation zieht Daten aus einer Datenbank oder API, die sich im Laufe der Zeit \u00e4ndern und die Reproduzierbarkeit beeintr\u00e4chtigen.<\/p>\n<p><strong>L\u00f6sung<\/strong>:<\/p>\n<ul>\n<li>Snapshot externe Daten und f\u00fcgen Sie sie in Ihr Repository oder Container ein oder<\/li>\n<li>Verwenden Sie versionierte API-Endpunkte und dokumentieren Sie die genaue Version \/ Datum, auf das zugegriffen wird<\/li>\n<\/ul>\n<h2>\u00dcberlegungen zu HPC und Cluster<\/h2>\n<p>Hochleistungs-Computing-Umgebungen stellen zus\u00e4tzliche Reproduzierbarkeitsprobleme vor:<\/p>\n<h3>Singularity \/ Apptainer statt Docker<\/h3>\n<p>Die meisten HPC-Zentren verbieten Docker aus Sicherheitsgr\u00fcnden. Stattdessen bieten sie <strong>Singularity<\/strong> (oder ihre Fork <strong>Apptainer<\/strong>). Singularity-Container werden aus Docker-Images erstellt:<\/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>Schl\u00fcsselunterschied<\/strong>: Singularity f\u00fchrt Container als aufrufende Benutzer (kein Root) aus, daher unterscheiden sich die Paketinstallationspfade. Testen Sie Ihr Dockerfile mit Singularit\u00e4t, um Probleme fr\u00fchzeitig zu erkennen.<\/p>\n<h3>Modulsysteme<\/h3>\n<p>Viele HPC-Cluster verwenden <strong>Umgebungsmodule<\/strong> (LMOD), um Softwareversionen zu verwalten. Sie k\u00f6nnen entweder:<\/p>\n<ul>\n<li>Laden Sie die erforderlichen Module, bevor Sie Ihren Container ausf\u00fchren (wenn Singularity darauf zugreifen kann), oder<\/li>\n<li>Erstellen Sie Ihren Container auf einem Basis-Image, das bereits ben\u00f6tigte Bibliotheken enth\u00e4lt<\/li>\n<\/ul>\n<h3>Parallele I\/O und MPI<\/h3>\n<p>Wenn Ihre Simulation MPI (Message Passing Interface) verwendet, stellen Sie sicher, dass Ihr Container eine kompatible MPI-Implementierung enth\u00e4lt. F\u00fcr die Singularit\u00e4t k\u00f6nnen Sie die MPI-Bibliotheken des Hosts <strong>Bind-Mount<\/strong>:<\/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>Installieren Sie alternativ Mpich oder OpenMPI im Container und stellen Sie sicher, dass die Netzwerkstruktur des Hosts (InfiniBand usw.) verwendet wird.<\/p>\n<h3>GPU-Unterst\u00fctzung<\/h3>\n<p>F\u00fcr GPU-beschleunigte Simulationen erfordern sowohl Docker als auch Singularity spezielle Flags:<\/p>\n<ul>\n<li>Docking: <code>--gpus all<\/code><\/li>\n<li>Singularit\u00e4t: <code>--nv<\/code><\/li>\n<\/ul>\n<p>Testen Sie die GPU-Funktionalit\u00e4t gr\u00fcndlich in Ihrem Container.<\/p>\n<h2>Schritt-f\u00fcr-Schritt-Implementierungshandbuch<\/h2>\n<p>Hier ist ein praktischer Workflow zur Implementierung reproduzierbarer Forschungsworkflows in Ihrem Simulationsprojekt:<\/p>\n<h3>Phase 1: Projektaufbau<\/h3>\n<ol>\n<li><strong>Versionskontrolle initialisieren<\/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>CONDA-Umgebung erstellen<\/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>Abh\u00e4ngigkeiten installieren<\/strong> und aufzeichnen:\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>Projektstruktur erstellen<\/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>Phase 2: Entwicklung mit CONDA<\/h3>\n<ul>\n<li>Entwickeln und testen Sie in der Conda-Umgebung<\/li>\n<li>Code-\u00c4nderungen h\u00e4ufig festlegen<\/li>\n<li>Aktualisieren Sie <code>environment.yml<\/code> beim Hinzuf\u00fcgen\/Entfernen von Paketen<\/li>\n<li>Verwenden Sie <code>.gitignore<\/code>, um generierte Ausgaben und gro\u00dfe Datendateien auszuschlie\u00dfen<\/li>\n<\/ul>\n<h3>Phase 3: Erstellen des Docker-Images<\/h3>\n<ol>\n<li><strong>Dockerfile erstellen<\/strong> (siehe Beispiel oben)<\/li>\n<li><strong>Bild erstellen<\/strong>:\n<pre><code class=\"language-bash\">docker build -t my-sim:latest .\n<\/code><\/pre>\n<\/li>\n<li><strong>Beh\u00e4lter testen<\/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 zur Ver\u00f6ffentlichung<\/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>Push to Registry<\/strong> (optional, zum Teilen):\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>Phase 4: Verifizierung und Freigabe<\/h3>\n<ol>\n<li><strong>Testreproduzierbarkeit<\/strong>: Lassen Sie einen Kollegen das Bild ziehen und ausf\u00fchren. Sie sollten identische Ergebnisse erhalten (bit-f\u00fcr-Bit identisch, wenn die Simulation deterministisch ist).<\/li>\n<li><strong>Dokument<\/strong>: Stellen Sie sicher <code>README.md<\/code> Enth\u00e4lt:\n<ul>\n<li>Wie Sie das Bild erhalten (Docker Hub, Registry oder <code>.sif<\/code> Datei)<\/li>\n<li>Wie man es ausf\u00fchrt (Full-Befehl)<\/li>\n<li>Eingabedateispezifikationen<\/li>\n<li>Erwartete Ausgabedateien und deren Formate<\/li>\n<li>Zitatinformationen<\/li>\n<\/ul>\n<\/li>\n<li><strong>Archiv<\/strong>: Hinterlegen Sie das Docker-Image (oder Singularit\u00e4t <code>.sif<\/code>) in einem Langzeitarchiv wie Zenodo oder Figshare und f\u00fcgen Sie den Link in die Methoden oder die Datenverf\u00fcgbarkeitserkl\u00e4rung Ihrer Arbeit ein.<\/li>\n<\/ol>\n<h3>Phase 5: Langzeitwartung<\/h3>\n<ul>\n<li>Aktualisieren Sie bei Code\u00e4nderungen das Docker-Image und markieren Sie es mit einer neuen Version (z. B. <code>v1.1<\/code>)<\/li>\n<li>Bewahren Sie alte Bilder \/ Tags so lange auf, wie Sie alte Ergebnisse reproduzieren m\u00fcssen<\/li>\n<li>Verwenden Sie Git-Tags, um Code-Commits mit Docker-Image-Versionen zu korrelieren<\/li>\n<\/ul>\n<h2>Fazit und n\u00e4chste Schritte<\/h2>\n<p>Die Implementierung von reproduzierbaren Forschungsworkflows ist keine einzige Werkzeugentscheidung \u2013 es ist eine <strong>Schichte-Strategie<\/strong>:<\/p>\n<ul>\n<li><strong>CONDA<\/strong> f\u00fcr leichtes, schnelles Umgebungsmanagement w\u00e4hrend der Entwicklung<\/li>\n<li><strong>Docker<\/strong> f\u00fcr unver\u00e4nderliche, tragbare Umgebungs-Snapshots, die f\u00fcr die Ver\u00f6ffentlichung und Zusammenarbeit geeignet sind<\/li>\n<li><strong>Git<\/strong> zur Versionskontrolle von Code, Dockerfiles und Umgebungsspezifikationen<\/li>\n<li><strong>Dokumentation<\/strong>, um den Workflow f\u00fcr andere verst\u00e4ndlich und nutzbar zu machen<\/li>\n<\/ul>\n<p>F\u00fcr Simulationsprojekte, bei denen Korrektheit und \u00dcberpr\u00fcfbarkeit von gr\u00f6\u00dfter Bedeutung sind, bietet diese Kombination eine robuste Grundlage. Beginnen Sie mit Conda f\u00fcr Ihr n\u00e4chstes Projekt, und sobald die Simulation funktioniert, investieren Sie die Zeit, um ein Docker-Image zu erstellen. Die Vorabkosten zahlen sich aus, wenn Sie (oder andere) die Simulation Monate oder Jahre sp\u00e4ter mit Zuversicht erneut ausf\u00fchren m\u00fcssen.<\/p>\n<p><strong>N\u00e4chste Schritte, die Sie heute unternehmen k\u00f6nnen:<\/strong><\/p>\n<ol>\n<li>Pr\u00fcfen Sie Ihre aktuellen Simulationsprojekte: Sind Umgebungen dokumentiert? Sind Abh\u00e4ngigkeiten angeheftet?<\/li>\n<li>Konvertieren Sie ein vorhandenes Projekt in Conda-Umgebungen mit <code>environment.yml<\/code><\/li>\n<li>Erstellen Sie ein Docker-Image f\u00fcr eine funktionierende Simulation und testen Sie es auf einer anderen Maschine<\/li>\n<li>Erkunden Sie die Singularit\u00e4tsrichtlinien Ihres HPC Centers und konvertieren Sie ein Docker-Image in ein Singularity-Format<\/li>\n<li>F\u00fcgen Sie Umgebungsspezifikationen und Beh\u00e4lterbilder in die zus\u00e4tzlichen Materialien Ihres n\u00e4chsten Papiers ein<\/li>\n<\/ol>\n<h2>Verwandte Anleitungen<\/h2>\n<ul>\n<li><a href=\"\/managing-research-software-through-tickets\">Verwalten von Forschungssoftware \u00fcber Tickets<\/a> \u2013 Strukturreproduzierbarkeit Arbeiten als nachverfolgte Probleme und Verbesserungen<\/li>\n<li><a href=\"\/managing-large-scale-pde-problems-strategies-solvers-and-hpc-case-studies\">Verwalten von PDE-Problemen im gro\u00dfen Ma\u00dfstab: Strategien, Solver und HPC-Fallstudien<\/a> \u2013 Skalieren Sie Ihre Simulationen unter Beibehaltung der Reproduzierbarkeit<\/li>\n<li><a href=\"\/tracking-long-term-technical-debt-in-research-software\">Nachverfolgung langfristiger technischer Schulden in der Forschungssoftware<\/a> \u2013 Verwenden Sie CI\/CD-Praktiken, um die Reproduzierbarkeit im Laufe der Zeit aufrechtzuerhalten<\/li>\n<li><a href=\"\/collaboration-between-developers-and-researchers-turning-innovation-into-scalable-impact\">Kollaboration zwischen Entwicklern und Forschern<\/a> \u2013 Reproduzierbarkeit \u00fcber Teamgrenzen hinweg sichern<\/li>\n<\/ul>\n<h2>Referenzen und Weiterlesen<\/h2>\n<ul>\n<li>Boettiger, C. (2015). <a href=\"https:\/\/doi.org\/10.1145\/2723872.2723882\"> Eine Einf\u00fchrung in Docker f\u00fcr reproduzierbare Forschung <\/a>. <em>ACM Sigops-Betriebssystem-\u00dcberpr\u00fcfung <\/em>.<\/li>\n<li>N\u00fcst, D., et al. (2020). <a href=\"https:\/\/doi.org\/10.1371\/journal.pcbi.1008319\">Zehn einfache Regeln f\u00fcr das Schreiben von Dockerfiles f\u00fcr reproduzierbare Datenwissenschaft <\/a>. <em>Plos Computational Biology <\/em>.<\/li>\n<li>Der Turing-Weg. <a href=\"https:\/\/book.the-turing-way.org\/reproducible-research\/overview\/overview-definitions\/\"> Definitionen der reproduzierbaren Forschung <\/a>.<\/li>\n<li>Fitzpatrick, B.G., et al. (2018). <a href=\"https:\/\/doi.org\/10.3389\/fcomp.2018.00001\">Probleme in der reproduzierbaren Simulationsforschung <\/a>. <em> Frontiers in Informatik <\/em>.<\/li>\n<li>Conda-Dokumentation. <a href=\"https:\/\/docs.conda.io\/projects\/conda\/en\/stable\/user-guide\/tasks\/manage-environments.html\"> Verwalten von Umgebungen <\/a>.<\/li>\n<\/ul>\n","protected":false,"raw":"<p>Reproduzierbare Recherche-Workflows stellen sicher, dass die Simulationsergebnisse von anderen (oder Ihrem zuk\u00fcnftigen Selbst) mithilfe derselben Daten-, Code- und Rechenumgebung exakt neu erstellt werden k\u00f6nnen. <strong>Docker<\/strong> Bietet eine vollst\u00e4ndige Containerisierung auf Systemebene f\u00fcr maximale Konsistenz \u00fcber Plattformen hinweg, w\u00e4hrend <strong>conda<\/strong> ein leichtes Paket- und Umgebungsmanagement bietet, das ideal f\u00fcr Python-basiertes wissenschaftliches Computing ist. F\u00fcr Simulationsprojekte empfehlen wir: (1) Conda f\u00fcr die t\u00e4gliche Entwicklung und Abh\u00e4ngigkeitsverwaltung, (2) Erstellen Sie Docker-Images, um Arbeitsumgebungen f\u00fcr die Ver\u00f6ffentlichung und Zusammenarbeit \"einzufrieren\" und (3) immer mit Versionskontrolle und gr\u00fcndlicher Dokumentation zu koppeln. Vermeiden Sie den h\u00e4ufigen Fehler, sich ausschlie\u00dflich auf ein Werkzeug zu verlassen - beides f\u00fcr eine robuste Reproduzierbarkeit zu kombinieren.<\/p>\n<h2>Einleitung: Die Reproduzierbarkeitsl\u00fccke in der Simulationsforschung<\/h2>\n<p>Wissenschaftliche Simulationsprojekte leiden oft unter einem stillen Ausfallmodus: Der Code hat gestern funktioniert, heute jedoch unterschiedliche Ergebnisse. Die zugrunde liegende Physik hat sich nicht ge\u00e4ndert - Ihre Rechenumgebung hat sich ge\u00e4ndert. Fehlende Paketversionen, ge\u00e4nderte Bibliotheksabh\u00e4ngigkeiten, Betriebssystemaktualisierungen oder sogar verschiedene Python-Interpreter k\u00f6nnen die Simulationsausgaben stillschweigend \u00e4ndern, manchmal auf schwer zu erkennende Weise.<\/p>\n<p>Dies ist mehr als eine Unannehmlichkeit. <strong>Reproduzierbarkeit<\/strong> ist der Eckpfeiler der kumulativen Wissenschaft - die F\u00e4higkeit anderer Forscher, Anspr\u00fcche zu \u00fcberpr\u00fcfen und auf Ihrer Arbeit aufzubauen. Wenn Simulationsergebnisse nicht zuverl\u00e4ssig wiederhergestellt werden k\u00f6nnen, erodiert Vertrauen, Papiere zur\u00fcckgezogen werden und wertvolle Forschungszeit verschwendet wird, um Umweltprobleme zu debuggen, anstatt Wissen zu erweitern.<\/p>\n<p>In diesem Handbuch werden wir untersuchen, wie reproduzierbare Forschungsworkflows f\u00fcr Simulationsprojekte mit <strong>docker<\/strong> und <strong>conda<\/strong> implementiert werden \u2013 zwei erg\u00e4nzende Tools, die zusammen eine robuste L\u00f6sung f\u00fcr die Konsistenz der Umgebung, das Abh\u00e4ngigkeitsmanagement und die langfristige Erhaltung von bieten Berechnungsmethoden.<\/p>\n<h2>Was ist reproduzierbare Forschung? Definitionen und Kernkomponenten<\/h2>\n<p>Im Kern bedeutet <strong>Reproduzierbare Forschung<\/strong>, dass ein unabh\u00e4ngiger Forscher die ver\u00f6ffentlichten Ergebnisse (Tabellen, Abbildungen, quantitative Ergebnisse) nur unter Verwendung der Originaldaten, des Codes und der Dokumentation regenerieren kann. Dies erfordert, wie durch den Turing-Weg definiert und in der Computerwissenschaft weit verbreitet ist, Folgendes erforderlich:<\/p>\n<ul>\n<li><strong>Datenverf\u00fcgbarkeit<\/strong>: Rohdaten sind zug\u00e4nglich (mit angemessenen Datenschutzhinweisen)<\/li>\n<li><strong>Codetransparenz<\/strong>: Alle Analyse- und Simulationsskripte werden gemeinsam genutzt<\/li>\n<li><strong>Dokumentation<\/strong>: Vollst\u00e4ndige Aufzeichnungen \u00fcber Softwareversionen, Parameter und Umgebungskonfigurationen<\/li>\n<li><strong>Umgebungskontrolle<\/strong>: Die genaue Laufzeitumgebung wird erfasst und rekonstruierbar<\/li>\n<\/ul>\n<p>Die Reproduzierbarkeit der Computer unterscheidet sich von der <strong>Replizabilit\u00e4t<\/strong> (\u00e4hnliche Schlussfolgerungen mit neuen Daten oder unabh\u00e4ngigen Methoden zu ziehen). Reproduzierbarkeit ist der Mindeststandard - es geht darum, dieselben Zahlen aus denselben Eingaben zu erhalten und die zugrunde liegenden wissenschaftlichen Behauptungen nicht zu validieren.<\/p>\n<blockquote><p><strong>Warum es f\u00fcr Simulationsprojekte wichtig ist <\/strong>: PDE-Solver, Finite-Elemente-Methoden und andere Simulations-Frameworks umfassen h\u00e4ufig komplexe Abh\u00e4ngigkeitsketten. Eine geringf\u00fcgige Versions\u00e4nderung in einer numerischen Bibliothek kann das Diskretisierungsverhalten, die Konvergenzkriterien oder das Runden ver\u00e4ndern und messbar unterschiedliche Ergebnisse erzielen. Reproduzierbare Workflows beseitigen diese Quelle der Unsicherheit.<\/p><\/blockquote>\n<h2>Docker f\u00fcr reproduzierbare wissenschaftliche Simulationen<\/h2>\n<h3>Was Docker bietet<\/h3>\n<p><strong>Docker<\/strong> ist eine Containerisierungsplattform, die eine Anwendung und ihre gesamte Laufzeitumgebung \u2013 Betriebssystem, Bibliotheken, Abh\u00e4ngigkeiten, Konfigurationsdateien \u2013 in ein tragbares, unver\u00e4nderliches Image packt. Wenn Sie einen Docker-Container ausf\u00fchren, f\u00fchren Sie genau dieselbe Umgebung aus, die unabh\u00e4ngig vom Hostsystem erstellt und getestet wurde.<\/p>\n<p>F\u00fcr Simulationsprojekte liefert Docker:<\/p>\n<ol>\n<li><strong>Umweltkonsistenz<\/strong>: \"Es funktioniert auf meiner Maschine.\" Der Container enth\u00e4lt bestimmte Versionen von Compilern, MPI-Implementierungen, Python-Interpreter und numerischen Bibliotheken.<\/li>\n<li><strong>Platform Portability<\/strong>: Ein Docker-Image, das auf einem Laptop erstellt wird, kann ohne \u00c4nderungen auf einem HPC-Cluster, einer Cloud-Instanz oder einer Workstation eines Kollegen ausgef\u00fchrt werden.<\/li>\n<li><strong>Isolation<\/strong>: Simulationsabh\u00e4ngigkeiten stehen nicht in Konflikt mit Systembibliotheken oder anderen Projekten.<\/li>\n<li><strong>Versions-Snapshots<\/strong>: Jedes Docker-Image ist unver\u00e4nderlich und kann f\u00fcr eine genaue zuk\u00fcnftige Wiedergabe markiert werden (z. B. <code>my-sim:paper-v1<\/code>).<\/li>\n<\/ol>\n<h3>Docker-Einschr\u00e4nkungen zu ber\u00fccksichtigen<\/h3>\n<p>Trotz seiner St\u00e4rken hat Docker wichtige Einschr\u00e4nkungen f\u00fcr das wissenschaftliche Rechnen:<\/p>\n<ul>\n<li><strong>Keine Silberkugel<\/strong>: Wie in \"Docker \u00fcbernimmt keine Reproduzierbarkeit\" (ArXiv 2026), k\u00f6nnen Container bei unterschiedlicher Hardware (CPU-Architektur, Gleitkommaoptimierungen) oder externen Services weiterhin nicht deterministisches Verhalten aufweisen. (Datenbank, Dateisystem) variieren.<\/li>\n<li><strong>Kernel-Abh\u00e4ngigkeit<\/strong>: Docker-Container teilen sich den Host-Kernel. Dies bedeutet, dass das Containerverhalten immer noch durch die Version und Konfiguration des Host-Kernels beeinflusst werden kann.<\/li>\n<li><strong>Gr\u00f6\u00dfe Overhead<\/strong>: Vollst\u00e4ndige OS-Bilder k\u00f6nnen gro\u00df sein (Hunderte von MB zu GB), obwohl schlanke Bilder wie <code>alpine<\/code> helfen.<\/li>\n<li><strong>HPC-Einschr\u00e4nkungen<\/strong>: Viele HPC-Zentren lassen Docker aufgrund von Sicherheitsbedenken nicht direkt zu. Sie verwenden stattdessen <strong>Singularity<\/strong> oder <strong>Apptainer<\/strong>. Sie k\u00f6nnen jedoch Singularity-Images aus Docker-Images erstellen, wodurch Docker zu einem tragf\u00e4higen Entwicklungswerkzeug wird.<\/li>\n<\/ul>\n<h3>Schreiben von DockerFiles f\u00fcr Simulationsprojekte<\/h3>\n<p>Die <strong>Dockerfile<\/strong> definiert, wie Sie Ihren Container erstellen. Nach den \u201eZehn einfachen Regeln f\u00fcr das Schreiben von Dockerfiles f\u00fcr reproduzierbare Forschung\u201c (N\u00fcst et al., 2020) sind die wichtigsten Praktiken:<\/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>Schl\u00fcsselregel<\/strong>: Alle Versionen explizit anheften \u2013 Basis-Image, OS-Pakete, Python-Pakete und sogar PIP-Version. Verwenden Sie <code>requirements.txt<\/code> oder <code>environment.yml<\/code> mit exakten Versionen (<code>package==1.2.3<\/code>, nicht <code>package&gt;=1.0<\/code>).<\/p>\n<h2>Conda f\u00fcr Umweltmanagement in der Forschung<\/h2>\n<h3>Was Conda bietet<\/h3>\n<p><strong>conda<\/strong> ist ein plattform\u00fcbergreifender Paket- und Umgebungsmanager, der nicht nur Python-Pakete, sondern auch Abh\u00e4ngigkeiten von Nicht-Python (C\/C++-Bibliotheken, Compiler, MPI) behandelt. Dies macht es besonders gut f\u00fcr wissenschaftliche Simulationen geeignet, wenn Sie m\u00f6glicherweise bestimmte Versionen von OpenMPI, FFTW oder HDF5 ben\u00f6tigen.<\/p>\n<p>Conda liefert:<\/p>\n<ol>\n<li><strong>Sprachagnostic<\/strong>: Installieren Sie Python, R, C\/C++ Bibliotheken und Systemtools in einer Umgebung.<\/li>\n<li><strong>Bin\u00e4re Abh\u00e4ngigkeiten<\/strong>: Vorkompilierte Pakete vermeiden die Kompilierung der H\u00f6lle auf verschiedenen Systemen.<\/li>\n<li><strong>Isolated Environments<\/strong>: Jedes Projekt erh\u00e4lt seine eigene Umgebung ohne Kreuzkontamination.<\/li>\n<li><strong>Export\/Import<\/strong>: <code>conda env export &gt; environment.yml<\/code> Erfasst die gesamte Umgebung f\u00fcr eine exakte Wiedergabe.<\/li>\n<\/ol>\n<h3>Best Practices von Conda<\/h3>\n<p>Basierend auf der MSI University of Minnesota und Anaconda Anleitung:<\/p>\n<ul>\n<li><strong>Niemals installieren in <code>base<\/code><\/strong>: Erstellen Sie f\u00fcr jedes Projekt eine neue Umgebung: <pre><code class=\"language-bash\">conda create --name my-simulation python=3.11\nconda activate my-simulation\n<\/code><\/pre><\/li>\n<li><strong>Community-Kan\u00e4le verwenden<\/strong>: Bevorzugen Sie <code>conda-forge<\/code> gegen\u00fcber Standardeinstellungen f\u00fcr aktuellere wissenschaftliche Pakete: <pre><code class=\"language-bash\">conda config --add channels conda-forge\nconda config --set channel_priority strict\n<\/code><\/pre><\/li>\n<li><strong>Alle Pakete auf einmal installieren<\/strong>: Dadurch werden Abh\u00e4ngigkeitskonflikte vermieden: <pre><code class=\"language-bash\">conda install numpy scipy matplotlib fipy\n<\/code><\/pre><\/li>\n<li><strong>Bestehende Umgebungen nicht \u00e4ndern<\/strong>: Wenn Sie neue Pakete ben\u00f6tigen, aktualisieren Sie entweder die Umgebungsspezifikation oder erstellen Sie eine neue Umgebung aus der aktualisierten YAML-Datei.<\/li>\n<li><strong>Clean exportieren<\/strong>: Entfernen Sie beim Freigeben plattformspezifische Pakete und PIP-installierte Elemente, die nicht unbedingt erforderlich sind: <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: Wann w\u00e4hlen Sie welche<\/h2>\n<p>Die Frage lautet nicht \"Docker oder Conda?\" - Sie l\u00f6sen verschiedene Probleme und sind <strong>Erg\u00e4nzung <\/strong>.<\/p>\n<table>\n<thead>\n<tr>\n<th>Aspekt<\/th>\n<th>Docking<\/th>\n<th>Konda<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><strong>Scope<\/strong><\/td>\n<td>Gesamte Betriebssystem + Laufzeit<\/td>\n<td>Paket &amp; Umgebungsmanager<\/td>\n<\/tr>\n<tr>\n<td><strong>Isolierung<\/strong><\/td>\n<td>Systemebene (Kernel-Namespace)<\/td>\n<td>User-Space-Umgebung<\/td>\n<\/tr>\n<tr>\n<td><strong>Gr\u00f6\u00dfe<\/strong><\/td>\n<td>Gro\u00df (100 MB\u20131 GB+)<\/td>\n<td>Klein (MBS)<\/td>\n<\/tr>\n<tr>\n<td><strong>Geschwindigkeit<\/strong><\/td>\n<td>langsamer zu bauen \/ zu \u00fcbertragen<\/td>\n<td>Sofortige Aktivierung<\/td>\n<\/tr>\n<tr>\n<td><strong>HPC-Unterst\u00fctzung<\/strong><\/td>\n<td>Begrenzt (Singularit\u00e4t funktioniert)<\/td>\n<td>Ausgezeichnet (Native)<\/td>\n<\/tr>\n<tr>\n<td><strong> Anwendungsfall<\/strong><\/td>\n<td>Ver\u00f6ffentlichung, Freigabe, Bereitstellung<\/td>\n<td>T\u00e4gliche Entwicklung, Erkundung<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h3>Praktische Empfehlung<\/h3>\n<ul>\n<li><strong>CONDA f\u00fcr die Entwicklung verwenden<\/strong>: Erstellen Sie schnell isolierte Umgebungen, testen Sie Abh\u00e4ngigkeiten und iterieren Sie den Code. Es ist leicht und schnell.<\/li>\n<li><strong>Docker f\u00fcr die Erhaltung verwenden<\/strong>: Sobald Ihre Simulation funktioniert, erstellen Sie ein Docker-Image, um die genaue Umgebung zu \"einfrieren\". Teilen Sie dieses Bild mit Mitarbeitern, h\u00e4ngen Sie es an Publikationen an oder verwenden Sie es f\u00fcr CI\/CD.<\/li>\n<li><strong>Kombinieren Sie beide<\/strong>: Entwickeln Sie in Conda und erstellen Sie dann eine Dockerdatei, die entweder: <ul> <li> die Conda-Umgebung in das Bild kopiert, oder <\/li> <li> die Umgebung mit den exportierten <code>environment.yml<\/code><\/li> neu erstellt. <\/ul><\/li>\n<\/ul>\n<p>Dieser geschichtete Ansatz gibt Ihnen Entwicklungsagilit\u00e4t und Publikations-Robustheit.<\/p>\n<h2>Integration von Docker und Conda in wissenschaftliche Workflows<\/h2>\n<h3>Strategie 1: Conda im Docker<\/h3>\n<p>Die h\u00e4ufigste Integration ist die Installation und Verwendung von Conda in einem Docker-Container. Dies gibt Ihnen die feink\u00f6rnige Paketverwaltung in Dockers Systemisolation.<\/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>: Nutzt das umfangreiche wissenschaftliche Paket-\u00d6kosystem von Conda; Konsistent mit lokalen Entwicklungs-Workflows.<br> <strong>cons<\/strong>: Gr\u00f6\u00dfere Bildgr\u00f6\u00dfe; Conda-Aktivierungsnuancen in Docker.<\/p>\n<h3>Strategie 2: Docker zur Umgebungserfassung<\/h3>\n<p>Entwickeln Sie lokal mit Conda, exportieren Sie die Umgebung und backen Sie sie in ein Docker-Image, ohne Conda zur Laufzeit auszuf\u00fchren:<\/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>Dies ist einfacher, verliert jedoch die Behandlung von Conda-Abh\u00e4ngigkeitsf\u00e4llen.<\/p>\n<h3>Strategie 3: Mehrstufige Builds f\u00fcr HPC<\/h3>\n<p>Erstellen Sie bei HPC-Clustern lokal das Docker-Image und konvertieren Sie es in Singularity:<\/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>Mit diesem Workflow k\u00f6nnen Sie sich mit Docker (Easy Testing) entwickeln und auf HPC (Singularity) bereitstellen.<\/p>\n<h2>H\u00e4ufige Fallstricke und wie man sie vermeidet<\/h2>\n<p>Basierend auf der Analyse der Reproduzierbarkeitsherausforderungen in der Simulationsforschung sind hier kritische Fehler zu vermeiden:<\/p>\n<h3>1. <strong>Fehlende oder unvollst\u00e4ndige Dokumentation<\/strong><\/h3>\n<p><strong>Problem<\/strong>: Sie haben ein funktionierendes Docker-Image, aber keine Aufzeichnung dar\u00fcber, wie es verwendet wird, welche Eingaben es erwartet oder wie Sie Ausgaben interpretieren.<\/p>\n<p><strong>L\u00f6sung<\/strong>: F\u00fcgen Sie <code>README.md<\/code> in den Beh\u00e4lter (oder neben dem Bild) ein mit:<\/p>\n<ul>\n<li>So f\u00fchren Sie die Simulation aus (Befehlszeilenargumente)<\/li>\n<li>Erwartete Eingabedateiformate<\/li>\n<li>Beschreibungen der Ausgabedatei<\/li>\n<li>Hardwareanforderungen (CPU, Speicher, GPU)<\/li>\n<li>Bekannte Einschr\u00e4nkungen<\/li>\n<\/ul>\n<h3>2. <strong>Unpinnende Abh\u00e4ngigkeiten<\/strong><\/h3>\n<p><strong>Problem<\/strong>: Verwenden von <code>numpy&gt;=1.0<\/code> oder <code>python=3.x<\/code> Erm\u00f6glicht automatische Updates, die das Verhalten \u00e4ndern k\u00f6nnen.<\/p>\n<p><strong>L\u00f6sung<\/strong>: Pin exakte Versionen in <code>environment.yml<\/code> und <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> Nicht-deterministische Simulationen <\/strong><\/h3>\n<p><strong>Problem<\/strong>: Selbst bei identischen Umgebungen f\u00fchren Simulationen aufgrund von Gleitkomma-Nicht-Assoziativit\u00e4t, parallelen Rassenbedingungen oder nicht initialisiertem Ged\u00e4chtnis zu leicht unterschiedlichen Ergebnissen.<\/p>\n<p><strong>L\u00f6sung<\/strong>:<\/p>\n<ul>\n<li>Setzen Sie deterministische Flags, sofern verf\u00fcgbar (z. B. OpenMP <code>OMP_NUM_THREADS=1<\/code>, BLAS-Gewinde<\/li>\n<li>Verwenden Sie feste zuf\u00e4llige Samen und dokumentieren Sie sie<\/li>\n<li>Testen Sie die Reproduzierbarkeit, indem Sie den Container mehrmals auf demselben Host ausf\u00fchren<\/li>\n<\/ul>\n<h3>4. <strong>Gro\u00dfe Daten in Containern<\/strong><\/h3>\n<p><strong>Problem<\/strong>: Das Backen gro\u00dfer Simulationsdatens\u00e4tze in Docker-Images bl\u00e4ht sie auf und verlangsamt die Verteilung.<\/p>\n<p><strong>L\u00f6sung<\/strong>: Halten Sie die Daten extern. Verwenden Sie Docker-Volumes oder Bindungs-Mounts, um Daten zur Laufzeit anzuh\u00e4ngen:<\/p>\n<pre><code class=\"language-bash\">docker run -v \/path\/to\/data:\/data my-sim:latest\n<\/code><\/pre>\n<p>Datenerwartungen klar dokumentieren.<\/p>\n<h3>5. <strong>HPC-Einschr\u00e4nkungen ignorieren<\/strong><\/h3>\n<p><strong>Problem<\/strong>: Docker-Images, die auf einem Laptop funktionieren, scheitern in einem HPC-Cluster aufgrund fehlender MPI-Implementierungen, inkompatibler Treiber oder Sicherheitsbeschr\u00e4nkungen.<\/p>\n<p><strong>L\u00f6sung<\/strong>:<\/p>\n<ul>\n<li>Testen Sie fr\u00fchzeitig in einer Cluster-\u00e4hnlichen Umgebung<\/li>\n<li>Verwenden Sie die Singularit\u00e4tskompatibilit\u00e4t, wenn Sie auf HPC abzielen<\/li>\n<li>Vermeiden Sie Docker-in-Docking-Muster. Bauen Sie auf einem Basis-Image auf, das dem Cluster-OS entspricht (z. B. CentOS \/ Rocky, wenn Cluster diese verwendet).<\/li>\n<\/ul>\n<h3>6. <strong>Keine Versionskontrolle f\u00fcr Dockerfiles und Umgebungsdateien<\/strong><\/h3>\n<p><strong>Problem<\/strong>: Sie haben ein Arbeitsbild, aber keine \u00c4nderungen an der Dockerfile oder <code>environment.yml<\/code>.<\/p>\n<p><strong>L\u00f6sung<\/strong>: Behandeln Sie Dockerfile- und Umgebungsspezifikationen als <strong>Code<\/strong>. Speichern Sie sie in Git neben Ihrem Simulationscode. Tag-Releases (z. B. <code>git tag -a v1.0 -m \"Paper submission\"<\/code>).<\/p>\n<h3>7. <strong>\u00dcberblickende externe Dienste<\/strong><\/h3>\n<p><strong>Problem<\/strong>: Ihre Simulation zieht Daten aus einer Datenbank oder API, die sich im Laufe der Zeit \u00e4ndern und die Reproduzierbarkeit beeintr\u00e4chtigen.<\/p>\n<p><strong>L\u00f6sung<\/strong>:<\/p>\n<ul>\n<li>Snapshot externe Daten und f\u00fcgen Sie sie in Ihr Repository oder Container ein oder<\/li>\n<li>Verwenden Sie versionierte API-Endpunkte und dokumentieren Sie die genaue Version \/ Datum, auf das zugegriffen wird<\/li>\n<\/ul>\n<h2>\u00dcberlegungen zu HPC und Cluster<\/h2>\n<p>Hochleistungs-Computing-Umgebungen stellen zus\u00e4tzliche Reproduzierbarkeitsprobleme vor:<\/p>\n<h3>Singularity \/ Apptainer statt Docker<\/h3>\n<p>Die meisten HPC-Zentren verbieten Docker aus Sicherheitsgr\u00fcnden. Stattdessen bieten sie <strong>Singularity<\/strong> (oder ihre Fork <strong>Apptainer<\/strong>). Singularity-Container werden aus Docker-Images erstellt:<\/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>Schl\u00fcsselunterschied<\/strong>: Singularity f\u00fchrt Container als aufrufende Benutzer (kein Root) aus, daher unterscheiden sich die Paketinstallationspfade. Testen Sie Ihr Dockerfile mit Singularit\u00e4t, um Probleme fr\u00fchzeitig zu erkennen.<\/p>\n<h3>Modulsysteme<\/h3>\n<p>Viele HPC-Cluster verwenden <strong>Umgebungsmodule<\/strong> (LMOD), um Softwareversionen zu verwalten. Sie k\u00f6nnen entweder:<\/p>\n<ul>\n<li>Laden Sie die erforderlichen Module, bevor Sie Ihren Container ausf\u00fchren (wenn Singularity darauf zugreifen kann), oder<\/li>\n<li>Erstellen Sie Ihren Container auf einem Basis-Image, das bereits ben\u00f6tigte Bibliotheken enth\u00e4lt<\/li>\n<\/ul>\n<h3>Parallele I\/O und MPI<\/h3>\n<p>Wenn Ihre Simulation MPI (Message Passing Interface) verwendet, stellen Sie sicher, dass Ihr Container eine kompatible MPI-Implementierung enth\u00e4lt. F\u00fcr die Singularit\u00e4t k\u00f6nnen Sie die MPI-Bibliotheken des Hosts <strong>Bind-Mount<\/strong>:<\/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>Installieren Sie alternativ Mpich oder OpenMPI im Container und stellen Sie sicher, dass die Netzwerkstruktur des Hosts (InfiniBand usw.) verwendet wird.<\/p>\n<h3>GPU-Unterst\u00fctzung<\/h3>\n<p>F\u00fcr GPU-beschleunigte Simulationen erfordern sowohl Docker als auch Singularity spezielle Flags:<\/p>\n<ul>\n<li>Docking: <code>--gpus all<\/code><\/li>\n<li>Singularit\u00e4t: <code>--nv<\/code><\/li>\n<\/ul>\n<p>Testen Sie die GPU-Funktionalit\u00e4t gr\u00fcndlich in Ihrem Container.<\/p>\n<h2>Schritt-f\u00fcr-Schritt-Implementierungshandbuch<\/h2>\n<p>Hier ist ein praktischer Workflow zur Implementierung reproduzierbarer Forschungsworkflows in Ihrem Simulationsprojekt:<\/p>\n<h3>Phase 1: Projektaufbau<\/h3>\n<ol>\n<li><strong>Versionskontrolle initialisieren<\/strong> (Git): <pre><code class=\"language-bash\">git init\ngit add .\ngit commit -m \"Initial project structure\"\n<\/code><\/pre><\/li>\n<li><strong>CONDA-Umgebung erstellen<\/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>Abh\u00e4ngigkeiten installieren<\/strong> und aufzeichnen: <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>Projektstruktur erstellen<\/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>Phase 2: Entwicklung mit CONDA<\/h3>\n<ul>\n<li>Entwickeln und testen Sie in der Conda-Umgebung<\/li>\n<li>Code-\u00c4nderungen h\u00e4ufig festlegen<\/li>\n<li>Aktualisieren Sie <code>environment.yml<\/code> beim Hinzuf\u00fcgen\/Entfernen von Paketen<\/li>\n<li>Verwenden Sie <code>.gitignore<\/code>, um generierte Ausgaben und gro\u00dfe Datendateien auszuschlie\u00dfen<\/li>\n<\/ul>\n<h3>Phase 3: Erstellen des Docker-Images<\/h3>\n<ol>\n<li><strong>Dockerfile erstellen<\/strong> (siehe Beispiel oben)<\/li>\n<li><strong>Bild erstellen<\/strong>: <pre><code class=\"language-bash\">docker build -t my-sim:latest .\n<\/code><\/pre><\/li>\n<li><strong>Beh\u00e4lter testen<\/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 zur Ver\u00f6ffentlichung<\/strong>: <pre><code class=\"language-bash\">docker tag my-sim:latest my-sim:paper-v1.0\n<\/code><\/pre><\/li>\n<li><strong>Push to Registry<\/strong> (optional, zum Teilen): <pre><code class=\"language-bash\">docker push my-registry.example.com\/my-sim:paper-v1.0\n<\/code><\/pre><\/li>\n<\/ol>\n<h3>Phase 4: Verifizierung und Freigabe<\/h3>\n<ol>\n<li><strong>Testreproduzierbarkeit<\/strong>: Lassen Sie einen Kollegen das Bild ziehen und ausf\u00fchren. Sie sollten identische Ergebnisse erhalten (bit-f\u00fcr-Bit identisch, wenn die Simulation deterministisch ist).<\/li>\n<li><strong>Dokument<\/strong>: Stellen Sie sicher <code>README.md<\/code> Enth\u00e4lt: <ul> <li>Wie Sie das Bild erhalten (Docker Hub, Registry oder <code>.sif<\/code> Datei)<\/li> <li>Wie man es ausf\u00fchrt (Full-Befehl)<\/li> <li>Eingabedateispezifikationen<\/li> <li>Erwartete Ausgabedateien und deren Formate<\/li> <li>Zitatinformationen<\/li> <\/ul><\/li>\n<li><strong>Archiv<\/strong>: Hinterlegen Sie das Docker-Image (oder Singularit\u00e4t <code>.sif<\/code>) in einem Langzeitarchiv wie Zenodo oder Figshare und f\u00fcgen Sie den Link in die Methoden oder die Datenverf\u00fcgbarkeitserkl\u00e4rung Ihrer Arbeit ein.<\/li>\n<\/ol>\n<h3>Phase 5: Langzeitwartung<\/h3>\n<ul>\n<li>Aktualisieren Sie bei Code\u00e4nderungen das Docker-Image und markieren Sie es mit einer neuen Version (z. B. <code>v1.1<\/code>)<\/li>\n<li>Bewahren Sie alte Bilder \/ Tags so lange auf, wie Sie alte Ergebnisse reproduzieren m\u00fcssen<\/li>\n<li>Verwenden Sie Git-Tags, um Code-Commits mit Docker-Image-Versionen zu korrelieren<\/li>\n<\/ul>\n<h2>Fazit und n\u00e4chste Schritte<\/h2>\n<p>Die Implementierung von reproduzierbaren Forschungsworkflows ist keine einzige Werkzeugentscheidung \u2013 es ist eine <strong>Schichte-Strategie<\/strong>:<\/p>\n<ul>\n<li><strong>CONDA<\/strong> f\u00fcr leichtes, schnelles Umgebungsmanagement w\u00e4hrend der Entwicklung<\/li>\n<li><strong>Docker<\/strong> f\u00fcr unver\u00e4nderliche, tragbare Umgebungs-Snapshots, die f\u00fcr die Ver\u00f6ffentlichung und Zusammenarbeit geeignet sind<\/li>\n<li><strong>Git<\/strong> zur Versionskontrolle von Code, Dockerfiles und Umgebungsspezifikationen<\/li>\n<li><strong>Dokumentation<\/strong>, um den Workflow f\u00fcr andere verst\u00e4ndlich und nutzbar zu machen<\/li>\n<\/ul>\n<p>F\u00fcr Simulationsprojekte, bei denen Korrektheit und \u00dcberpr\u00fcfbarkeit von gr\u00f6\u00dfter Bedeutung sind, bietet diese Kombination eine robuste Grundlage. Beginnen Sie mit Conda f\u00fcr Ihr n\u00e4chstes Projekt, und sobald die Simulation funktioniert, investieren Sie die Zeit, um ein Docker-Image zu erstellen. Die Vorabkosten zahlen sich aus, wenn Sie (oder andere) die Simulation Monate oder Jahre sp\u00e4ter mit Zuversicht erneut ausf\u00fchren m\u00fcssen.<\/p>\n<p><strong>N\u00e4chste Schritte, die Sie heute unternehmen k\u00f6nnen:<\/strong><\/p>\n<ol>\n<li>Pr\u00fcfen Sie Ihre aktuellen Simulationsprojekte: Sind Umgebungen dokumentiert? Sind Abh\u00e4ngigkeiten angeheftet?<\/li>\n<li>Konvertieren Sie ein vorhandenes Projekt in Conda-Umgebungen mit <code>environment.yml<\/code><\/li>\n<li>Erstellen Sie ein Docker-Image f\u00fcr eine funktionierende Simulation und testen Sie es auf einer anderen Maschine<\/li>\n<li>Erkunden Sie die Singularit\u00e4tsrichtlinien Ihres HPC Centers und konvertieren Sie ein Docker-Image in ein Singularity-Format<\/li>\n<li>F\u00fcgen Sie Umgebungsspezifikationen und Beh\u00e4lterbilder in die zus\u00e4tzlichen Materialien Ihres n\u00e4chsten Papiers ein<\/li>\n<\/ol>\n<h2>Verwandte Anleitungen<\/h2>\n<ul>\n<li><a href=\"\/managing-research-software-through-tickets\">Verwalten von Forschungssoftware \u00fcber Tickets<\/a> \u2013 Strukturreproduzierbarkeit Arbeiten als nachverfolgte Probleme und Verbesserungen<\/li>\n<li><a href=\"\/managing-large-scale-pde-problems-strategies-solvers-and-hpc-case-studies\">Verwalten von PDE-Problemen im gro\u00dfen Ma\u00dfstab: Strategien, Solver und HPC-Fallstudien<\/a> \u2013 Skalieren Sie Ihre Simulationen unter Beibehaltung der Reproduzierbarkeit<\/li>\n<li><a href=\"\/tracking-long-term-technical-debt-in-research-software\">Nachverfolgung langfristiger technischer Schulden in der Forschungssoftware<\/a> \u2013 Verwenden Sie CI\/CD-Praktiken, um die Reproduzierbarkeit im Laufe der Zeit aufrechtzuerhalten<\/li>\n<li><a href=\"\/collaboration-between-developers-and-researchers-turning-innovation-into-scalable-impact\">Kollaboration zwischen Entwicklern und Forschern<\/a> \u2013 Reproduzierbarkeit \u00fcber Teamgrenzen hinweg sichern<\/li>\n<\/ul>\n<h2>Referenzen und Weiterlesen<\/h2>\n<ul>\n<li>Boettiger, C. (2015). <a href=\"https:\/\/doi.org\/10.1145\/2723872.2723882\"> Eine Einf\u00fchrung in Docker f\u00fcr reproduzierbare Forschung <\/a>. <em>ACM Sigops-Betriebssystem-\u00dcberpr\u00fcfung <\/em>.<\/li>\n<li>N\u00fcst, D., et al. (2020). <a href=\"https:\/\/doi.org\/10.1371\/journal.pcbi.1008319\">Zehn einfache Regeln f\u00fcr das Schreiben von Dockerfiles f\u00fcr reproduzierbare Datenwissenschaft <\/a>. <em>Plos Computational Biology <\/em>.<\/li>\n<li>Der Turing-Weg. <a href=\"https:\/\/book.the-turing-way.org\/reproducible-research\/overview\/overview-definitions\/\"> Definitionen der reproduzierbaren Forschung <\/a>.<\/li>\n<li>Fitzpatrick, B.G., et al. (2018). <a href=\"https:\/\/doi.org\/10.3389\/fcomp.2018.00001\">Probleme in der reproduzierbaren Simulationsforschung <\/a>. <em> Frontiers in Informatik <\/em>.<\/li>\n<li>Conda-Dokumentation. <a href=\"https:\/\/docs.conda.io\/projects\/conda\/en\/stable\/user-guide\/tasks\/manage-environments.html\"> Verwalten von Umgebungen <\/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\"> 9<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span>Reproduzierbare Recherche-Workflows stellen sicher, dass die Simulationsergebnisse von anderen (oder Ihrem zuk\u00fcnftigen Selbst) mithilfe derselben Daten-, Code- und Rechenumgebung exakt neu erstellt werden k\u00f6nnen. Docker Bietet eine vollst\u00e4ndige Containerisierung auf Systemebene f\u00fcr maximale Konsistenz \u00fcber Plattformen hinweg, w\u00e4hrend conda ein leichtes Paket- und Umgebungsmanagement bietet, das ideal f\u00fcr Python-basiertes wissenschaftliches Computing ist. F\u00fcr Simulationsprojekte empfehlen [&hellip;]<\/p>\n","protected":false,"raw":""},"author":3,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_locale":"de_DE","_original_post":"https:\/\/matforge.org\/?p=199","iawp_total_views":0,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-848","post","type-post","status-publish","format-standard","hentry","category-simulation-modeling-projects","de-DE"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.1 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Reproduzierbare Forschungsworkflows: Docker und Conda f\u00fcr Simulationsprojekte - 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\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Reproduzierbare Forschungsworkflows: Docker und Conda f\u00fcr Simulationsprojekte - matforge.org\" \/>\n<meta property=\"og:description\" content=\"Reading Time:  9 minutesReproduzierbare Recherche-Workflows stellen sicher, dass die Simulationsergebnisse von anderen (oder Ihrem zuk\u00fcnftigen Selbst) mithilfe derselben Daten-, Code- und Rechenumgebung exakt neu erstellt werden k\u00f6nnen. Docker Bietet eine vollst\u00e4ndige Containerisierung auf Systemebene f\u00fcr maximale Konsistenz \u00fcber Plattformen hinweg, w\u00e4hrend conda ein leichtes Paket- und Umgebungsmanagement bietet, das ideal f\u00fcr Python-basiertes wissenschaftliches Computing ist. F\u00fcr Simulationsprojekte empfehlen [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/matforge.org\/de\/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-30T12:22:26+00:00\" \/>\n<meta name=\"author\" content=\"Tomas Delgado\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Tomas Delgado\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"15\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/\"},\"author\":{\"name\":\"Tomas Delgado\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/518cdd1f18dd092f4ed738d68e540061\"},\"headline\":\"Reproduzierbare Forschungsworkflows: Docker und Conda f\u00fcr Simulationsprojekte\",\"datePublished\":\"2026-07-30T12:22:26+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/\"},\"wordCount\":2424,\"commentCount\":0,\"articleSection\":[\"Simulation & amp; Modellierungsprojekte\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/matforge.org\\\/de\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/\",\"url\":\"https:\\\/\\\/matforge.org\\\/de\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/\",\"name\":\"Reproduzierbare Forschungsworkflows: Docker und Conda f\u00fcr Simulationsprojekte - matforge.org\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#website\"},\"datePublished\":\"2026-07-30T12:22:26+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/518cdd1f18dd092f4ed738d68e540061\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/matforge.org\\\/de\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/matforge.org\\\/de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Reproduzierbare Forschungsworkflows: Docker und Conda f\u00fcr Simulationsprojekte\"}]},{\"@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\":\"de\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/518cdd1f18dd092f4ed738d68e540061\",\"name\":\"Tomas Delgado\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@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":"Reproduzierbare Forschungsworkflows: Docker und Conda f\u00fcr Simulationsprojekte - 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\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/","og_locale":"de_DE","og_type":"article","og_title":"Reproduzierbare Forschungsworkflows: Docker und Conda f\u00fcr Simulationsprojekte - matforge.org","og_description":"Reading Time:  9 minutesReproduzierbare Recherche-Workflows stellen sicher, dass die Simulationsergebnisse von anderen (oder Ihrem zuk\u00fcnftigen Selbst) mithilfe derselben Daten-, Code- und Rechenumgebung exakt neu erstellt werden k\u00f6nnen. Docker Bietet eine vollst\u00e4ndige Containerisierung auf Systemebene f\u00fcr maximale Konsistenz \u00fcber Plattformen hinweg, w\u00e4hrend conda ein leichtes Paket- und Umgebungsmanagement bietet, das ideal f\u00fcr Python-basiertes wissenschaftliches Computing ist. F\u00fcr Simulationsprojekte empfehlen [&hellip;]","og_url":"https:\/\/matforge.org\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/","og_site_name":"matforge.org","article_published_time":"2026-07-30T12:22:26+00:00","author":"Tomas Delgado","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Tomas Delgado","Gesch\u00e4tzte Lesezeit":"15\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/matforge.org\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/#article","isPartOf":{"@id":"https:\/\/matforge.org\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/"},"author":{"name":"Tomas Delgado","@id":"https:\/\/matforge.org\/#\/schema\/person\/518cdd1f18dd092f4ed738d68e540061"},"headline":"Reproduzierbare Forschungsworkflows: Docker und Conda f\u00fcr Simulationsprojekte","datePublished":"2026-07-30T12:22:26+00:00","mainEntityOfPage":{"@id":"https:\/\/matforge.org\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/"},"wordCount":2424,"commentCount":0,"articleSection":["Simulation & amp; Modellierungsprojekte"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/matforge.org\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/matforge.org\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/","url":"https:\/\/matforge.org\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/","name":"Reproduzierbare Forschungsworkflows: Docker und Conda f\u00fcr Simulationsprojekte - matforge.org","isPartOf":{"@id":"https:\/\/matforge.org\/#website"},"datePublished":"2026-07-30T12:22:26+00:00","author":{"@id":"https:\/\/matforge.org\/#\/schema\/person\/518cdd1f18dd092f4ed738d68e540061"},"breadcrumb":{"@id":"https:\/\/matforge.org\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/matforge.org\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/matforge.org\/de\/reproducible-research-workflows-docker-and-conda-for-simulation-projects\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/matforge.org\/de\/"},{"@type":"ListItem","position":2,"name":"Reproduzierbare Forschungsworkflows: Docker und Conda f\u00fcr Simulationsprojekte"}]},{"@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":"de"},{"@type":"Person","@id":"https:\/\/matforge.org\/#\/schema\/person\/518cdd1f18dd092f4ed738d68e540061","name":"Tomas Delgado","image":{"@type":"ImageObject","inLanguage":"de","@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\/848","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=848"}],"version-history":[{"count":1,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/848\/revisions"}],"predecessor-version":[{"id":960,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/848\/revisions\/960"}],"wp:attachment":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/media?parent=848"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/categories?post=848"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/tags?post=848"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}