pybiolib 1.1.1881__py3-none-any.whl → 1.2.7.dev0__py3-none-any.whl

biolib/compute_node/job_worker/executors/docker_executor.py

@@ -1,44 +1,41 @@
+import io
 import json
+import os
+import re
+import shlex
 import subprocess
+import tarfile
 import tempfile
 import time
-import tarfile
 import zipfile
-import os
-import io
-import re
-import shlex
 from copy import copy
 from datetime import datetime
 
 import docker  # type: ignore
 import docker.types  # type: ignore
-
-from docker.errors import ImageNotFound, APIError  # type: ignore
+from docker.errors import APIError, ImageNotFound  # type: ignore
 from docker.models.containers import Container  # type: ignore
 
 from biolib import utils
-
 from biolib._internal.runtime import RuntimeJobDataDict
 from biolib.biolib_binary_format import ModuleInput, ModuleOutputV2
+from biolib.biolib_binary_format.file_in_container import FileInContainer
 from biolib.biolib_docker_client import BiolibDockerClient
-from biolib.biolib_errors import DockerContainerNotFoundDuringExecutionException, BioLibError
+from biolib.biolib_errors import BioLibError, DockerContainerNotFoundDuringExecutionException
 from biolib.biolib_logging import logger, logger_no_user_data
 from biolib.compute_node import utils as compute_node_utils
 from biolib.compute_node.cloud_utils import CloudUtils
 from biolib.compute_node.job_worker.docker_image_cache import DockerImageCache
-from biolib.biolib_binary_format.file_in_container import FileInContainer
 from biolib.compute_node.job_worker.executors.docker_types import DockerDiffKind
-from biolib.compute_node.job_worker.executors.types import StatusUpdate, LocalExecutorOptions
+from biolib.compute_node.job_worker.executors.types import LocalExecutorOptions, StatusUpdate
 from biolib.compute_node.job_worker.mappings import Mappings, path_without_first_folder
-from biolib.compute_node.job_worker.utils import ComputeProcessException
 from biolib.compute_node.job_worker.utilization_reporter_thread import UtilizationReporterThread
+from biolib.compute_node.job_worker.utils import ComputeProcessException
 from biolib.compute_node.utils import SystemExceptionCodes
-from biolib.typing_utils import List, Dict, Optional
+from biolib.typing_utils import Dict, List, Optional
 
 
 class DockerExecutor:
-
     def __init__(self, options: LocalExecutorOptions) -> None:
         self._options: LocalExecutorOptions = options
         self._is_cleaning_up = False
@@ -83,11 +80,12 @@ class DockerExecutor:
             raise Exception('Docker container was None')
         return self._docker_container
 
-    def execute_module(self, module_input_serialized: bytes, module_output_path: str) -> None:
+    def execute_module(self, module_input_path: str, module_output_path: str) -> None:
         try:
             job_uuid = self._options['job']['public_id']
             send_status_update = self._options['send_status_update']
-            module_input = ModuleInput(module_input_serialized).deserialize()
+            with open(module_input_path, 'rb') as fp:
+                module_input = ModuleInput(fp.read()).deserialize()
 
             send_status_update(StatusUpdate(progress=55, log_message='Pulling images...'))
 
@@ -115,35 +113,49 @@ class DockerExecutor:
             except Exception:  # pylint: disable=broad-except
                 logger_no_user_data.error('DockerExecutor failed to clean up container')
 
-    def _pull(self):
-        try:
-            start_time = time.time()
-            if utils.IS_RUNNING_IN_CLOUD and not self._options['job'].get('federated_job_uuid'):
-                DockerImageCache().get(
-                    image_uri=self._absolute_image_uri,
-                    estimated_image_size_bytes=self._options['module']['estimated_image_size_bytes'],
-                    job_id=self._options['job']['public_id'],
-                )
-            else:
-                docker_client = BiolibDockerClient.get_docker_client()
-                try:
-                    docker_client.images.get(self._absolute_image_uri)
-                except ImageNotFound:
-                    job_uuid = self._options['job'].get('federated_job_uuid') or self._options['job']['public_id']
-                    docker_client.images.pull(
-                        self._absolute_image_uri,
-                        auth_config={'username': 'biolib', 'password': f',{job_uuid}'},
-                    )
+    def _pull(self) -> None:
+        retries = 3
+        last_error: Optional[Exception] = None
+        estimated_image_size_bytes = self._options['module']['estimated_image_size_bytes']
+        assert estimated_image_size_bytes is not None, 'No estimated image size'
 
-            logger_no_user_data.debug(f'Pulled image in: {time.time() - start_time}')
+        for retry_count in range(retries + 1):
+            if retry_count > 0:
+                logger_no_user_data.debug(f'Retrying Docker image pull of "{self._absolute_image_uri}"')
+                time.sleep(5 * retry_count)
+            try:
+                start_time = time.time()
+                if utils.IS_RUNNING_IN_CLOUD and not self._options['job'].get('federated_job_uuid'):
+                    DockerImageCache().get(
+                        image_uri=self._absolute_image_uri,
+                        estimated_image_size_bytes=estimated_image_size_bytes,
+                        job_id=self._options['job']['public_id'],
+                    )
+                else:
+                    docker_client = BiolibDockerClient.get_docker_client()
+                    try:
+                        docker_client.images.get(self._absolute_image_uri)
+                    except ImageNotFound:
+                        job_uuid = self._options['job'].get('federated_job_uuid') or self._options['job']['public_id']
+                        docker_client.images.pull(
+                            self._absolute_image_uri,
+                            auth_config={'username': 'biolib', 'password': f',{job_uuid}'},
+                        )
+
+                logger_no_user_data.debug(f'Pulled image in: {time.time() - start_time}')
+                return
+            except Exception as error:
+                logger_no_user_data.warning(
+                    f'Pull of Docker image "{self._absolute_image_uri}" returned error: {error}'
+                )
+                last_error = error
 
-        except Exception as exception:
-            raise ComputeProcessException(
-                exception,
-                SystemExceptionCodes.FAILED_TO_PULL_DOCKER_IMAGE.value,
-                self._send_system_exception,
-                may_contain_user_data=False
-            ) from exception
+        raise ComputeProcessException(
+            last_error or Exception('Retries exceeded: failed to pull Docker image'),
+            SystemExceptionCodes.FAILED_TO_PULL_DOCKER_IMAGE.value,
+            self._send_system_exception,
+            may_contain_user_data=False,
+        )
 
     def _execute_helper(self, module_input, module_output_path: str) -> None:
         job_uuid = self._options['job']['public_id']
@@ -154,10 +166,10 @@ class DockerExecutor:
             logger_no_user_data.debug(f'Job "{job_uuid}" starting utilization metrics reporter thread...')
             config = CloudUtils.get_webserver_config()
             node_auth_token = config['compute_node_info']['auth_token']  # pylint: disable=unsubscriptable-object
-            cloud_job = self._options["cloud_job"]
+            cloud_job = self._options['cloud_job']
             include_gpu_stats = False
             if cloud_job:
-                include_gpu_stats = cloud_job.get("reserved_gpu_count", 0) > 0
+                include_gpu_stats = cloud_job.get('reserved_gpu_count', 0) > 0
             UtilizationReporterThread(
                 container=self._container,
                 job_uuid=job_uuid,
@@ -212,7 +224,7 @@ class DockerExecutor:
             raise ComputeProcessException(
                 MemoryError(),
                 SystemExceptionCodes.OUT_OF_MEMORY.value,
-                self._send_system_exception
+                self._send_system_exception,
             )
 
         logger_no_user_data.debug(f'Docker container exited with code {exit_code} for {job_uuid}')
@@ -243,24 +255,23 @@ class DockerExecutor:
         for path_to_delete in [self._input_tar_path, self._runtime_tar_path]:
             if os.path.exists(path_to_delete):
                 os.remove(path_to_delete)
-        logger_no_user_data.debug(f"Deleted tars in: {time.time() - tar_time}")
+        logger_no_user_data.debug(f'Deleted tars in: {time.time() - tar_time}')
 
         container_time = time.time()
         if self._docker_container:
             self._docker_container.remove(force=True)
 
         if utils.IS_RUNNING_IN_CLOUD:
-            DockerImageCache().detach_job(
-                image_uri=self._absolute_image_uri,
-                job_id=self._options['job']['public_id']
-            )
+            DockerImageCache().detach_job(image_uri=self._absolute_image_uri, job_id=self._options['job']['public_id'])
 
-        logger_no_user_data.debug(f"Deleted compute container in: {time.time() - container_time}")
+        logger_no_user_data.debug(f'Deleted compute container in: {time.time() - container_time}')
         self._tmp_secrets_dir.cleanup()
 
     # TODO: type this method
     def _initialize_docker_container(self, module_input):
         try:
+            job_uuid = self._options['job']['public_id']
+            logger_no_user_data.debug(f'Job "{job_uuid}" initializing Docker container...')
             module = self._options['module']
             logger.debug(f"Initializing docker container with command: {module['command']}")
 
@@ -274,6 +285,8 @@ class DockerExecutor:
                 job_requested_machine=self._options['job']['requested_machine'],
                 job_uuid=self._options['job']['public_id'],
                 job_auth_token=self._options['job']['auth_token'],
+                app_uri=self._options['job']['app_uri'],
+                is_environment_biolib_cloud=bool(utils.IS_RUNNING_IN_CLOUD),
             )
             secrets: Dict[str, str] = dict(
                 **module.get('secrets', {}),
@@ -290,32 +303,40 @@ class DockerExecutor:
             )
             if app_version_created_at < datetime(2022, 11, 30, 0, 0):
                 environment_vars = module.get('secrets', {})
-                environment_vars.update({
-                    'BIOLIB_JOB_UUID': self._options['job']['public_id'],
-                    'BIOLIB_JOB_AUTH_TOKEN': self._options['job']['auth_token']
-                })
+                environment_vars.update(
+                    {
+                        'BIOLIB_JOB_UUID': self._options['job']['public_id'],
+                        'BIOLIB_JOB_AUTH_TOKEN': self._options['job']['auth_token'],
+                    }
+                )
 
             if utils.IS_RUNNING_IN_CLOUD and self._options['cloud_job']:
-                environment_vars.update({
-                    'BIOLIB_JOB_MAX_RUNTIME_IN_SECONDS': self._options['cloud_job']['max_runtime_in_seconds'],
-                })
+                environment_vars.update(
+                    {
+                        'BIOLIB_JOB_MAX_RUNTIME_IN_SECONDS': self._options['cloud_job']['max_runtime_in_seconds'],
+                    }
+                )
 
+            logger_no_user_data.debug(f'Job "{job_uuid}" initializing Docker container. Getting IPs for proxies...')
             for proxy in self._options['remote_host_proxies']:
                 proxy_ip = proxy.get_ip_address_on_network(internal_network)
                 if proxy.is_app_caller_proxy:
                     logger_no_user_data.debug('Found app caller proxy, setting both base URLs in compute container')
-                    environment_vars.update({
-                        'BIOLIB_BASE_URL': f'http://{proxy_ip}',
-                        'BIOLIB_CLOUD_BASE_URL': f'http://{proxy_ip}',
-                        # This should be removed eventually, but will break apps calling apps on older versions
-                        'BIOLIB_CLOUD_RESULTS_BASE_URL': f'http://{proxy_ip}',
-                        'BIOLIB_CLOUD_JOB_STORAGE_BASE_URL': f'http://{proxy_ip}',
-                        # Inform container if we are targeting public biolib as we change the BIOLIB_BASE_URL
-                        'BIOLIB_ENVIRONMENT_IS_PUBLIC_BIOLIB': bool(utils.BASE_URL_IS_PUBLIC_BIOLIB)
-                    })
+                    environment_vars.update(
+                        {
+                            'BIOLIB_BASE_URL': f'http://{proxy_ip}',
+                            'BIOLIB_CLOUD_BASE_URL': f'http://{proxy_ip}',
+                            # This should be removed eventually, but will break apps calling apps on older versions
+                            'BIOLIB_CLOUD_RESULTS_BASE_URL': f'http://{proxy_ip}',
+                            'BIOLIB_CLOUD_JOB_STORAGE_BASE_URL': f'http://{proxy_ip}',
+                            # Inform container if we are targeting public biolib as we change the BIOLIB_BASE_URL
+                            'BIOLIB_ENVIRONMENT_IS_PUBLIC_BIOLIB': bool(utils.BASE_URL_IS_PUBLIC_BIOLIB),
+                        }
+                    )
                 else:
                     extra_hosts[proxy.hostname] = proxy_ip
 
+            logger_no_user_data.debug(f'Job "{job_uuid}" initializing Docker container. Constructing container args...')
             create_container_args = {
                 'environment': environment_vars,
                 'extra_hosts': extra_hosts,
@@ -327,45 +348,38 @@ class DockerExecutor:
 
             if self._options['job'].get('arguments_override_command'):
                 # In this case, arguments contains a user specified command to run in the app
-                create_container_args.update({
-                    'command': module_input['arguments'],
-                    'entrypoint': ''
-                })
+                create_container_args.update({'command': module_input['arguments'], 'entrypoint': ''})
 
             else:
-                create_container_args.update({
-                    'command': shlex.split(module['command']) + module_input['arguments']
-                })
+                create_container_args.update({'command': shlex.split(module['command']) + module_input['arguments']})
 
             app_version = self._options['job']['app_version']
             if app_version.get('main_output_file') or app_version.get('stdout_render_type') == 'text':
                 create_container_args['tty'] = True
 
             if utils.IS_RUNNING_IN_CLOUD:
-                cloud_job = self._options["cloud_job"]
+                cloud_job = self._options['cloud_job']
                 create_container_args['mem_limit'] = f'{cloud_job["reserved_memory_in_bytes"]}b'
-                create_container_args['nano_cpus'] = cloud_job["reserved_cpu_in_nano_shares"]
+                create_container_args['nano_cpus'] = cloud_job['reserved_cpu_in_nano_shares']
+                create_container_args['pids_limit'] = 10_000
 
                 biolib_identity_user_email: Optional[str] = cloud_job.get('biolib_identity_user_email')
                 if biolib_identity_user_email:
-                    create_container_args['environment'].update({
-                        'BIOLIB_IDENTITY_USER_EMAIL': biolib_identity_user_email
-                    })
+                    create_container_args['environment'].update(
+                        {'BIOLIB_IDENTITY_USER_EMAIL': biolib_identity_user_email}
+                    )
 
             docker_runtime = os.getenv('BIOLIB_DOCKER_RUNTIME')
             if docker_runtime is not None:
                 create_container_args['runtime'] = docker_runtime
 
-            self._docker_container = BiolibDockerClient.get_docker_client().containers.create(
-                **create_container_args
-            )
-
-            logger_no_user_data.debug('Finished initializing docker container')
+            docker_client = BiolibDockerClient.get_docker_client()
+            logger_no_user_data.debug(f'Job "{job_uuid}" initializing Docker container. Creating container...')
+            self._docker_container = docker_client.containers.create(**create_container_args)
+            logger_no_user_data.debug(f'Job "{job_uuid}" finished initializing Docker container.')
         except Exception as exception:
             raise ComputeProcessException(
-                exception,
-                SystemExceptionCodes.FAILED_TO_START_COMPUTE_CONTAINER.value,
-                self._send_system_exception
+                exception, SystemExceptionCodes.FAILED_TO_START_COMPUTE_CONTAINER.value, self._send_system_exception
             ) from exception
 
     def _add_file_to_tar(self, tar, current_path, mapped_path, data):
@@ -432,7 +446,7 @@ class DockerExecutor:
             raise ComputeProcessException(
                 exception,
                 SystemExceptionCodes.FAILED_TO_COPY_INPUT_FILES_TO_COMPUTE_CONTAINER.value,
-                self._send_system_exception
+                self._send_system_exception,
             ) from exception
 
     def _map_and_copy_runtime_files_to_container(self, runtime_zip_data, arguments: List[str], remove_root_folder=True):
@@ -447,17 +461,17 @@ class DockerExecutor:
             raise ComputeProcessException(
                 exception,
                 SystemExceptionCodes.FAILED_TO_COPY_RUNTIME_FILES_TO_COMPUTE_CONTAINER.value,
-                self._send_system_exception
+                self._send_system_exception,
             ) from exception
 
     def _write_module_output_to_file(
-            self,
-            arguments: List[str],
-            exit_code: int,
-            module_output_path: str,
-            stderr: bytes,
-            stdout: bytes,
-            pre_start_diff: List[Dict],
+        self,
+        arguments: List[str],
+        exit_code: int,
+        module_output_path: str,
+        stderr: bytes,
+        stdout: bytes,
+        pre_start_diff: List[Dict],
     ) -> None:
         mapped_files: List[FileInContainer] = []
         try:
@@ -502,9 +516,11 @@ class DockerExecutor:
             result = subprocess.run(
                 args=[
                     'ctr',
-                    '--namespace', 'moby',
+                    '--namespace',
+                    'moby',
                     'snapshots',
-                    '--snapshotter', 'nydus',
+                    '--snapshotter',
+                    'nydus',
                     'mounts',
                     '/some_arbitrary_path',
                     str(self._container.id),
@@ -526,9 +542,10 @@ class DockerExecutor:
         pre_start_diff_paths = [obj['Path'] for obj in pre_start_diff]
         post_run_diff = self._container.diff()
         run_diff_paths: List[str] = [
-            obj['Path'] for obj in post_run_diff if
-            obj['Kind'] in (DockerDiffKind.CHANGED.value, DockerDiffKind.ADDED.value) and
-            obj['Path'] not in pre_start_diff_paths
+            obj['Path']
+            for obj in post_run_diff
+            if obj['Kind'] in (DockerDiffKind.CHANGED.value, DockerDiffKind.ADDED.value)
+            and obj['Path'] not in pre_start_diff_paths
         ]
 
         known_directories = set()
@@ -538,7 +555,7 @@ class DockerExecutor:
                 if idx == 0:
                     continue  # always skip root
 
-                folder = '/' + '/'.join(parent_folders[1:idx + 1])
+                folder = '/' + '/'.join(parent_folders[1 : idx + 1])
                 known_directories.add(folder)
 
         def path_is_included_in_from_mappings(path: str) -> bool:
@@ -558,11 +575,13 @@ class DockerExecutor:
         files_and_empty_dirs: List[FileInContainer] = []
         for path in run_diff_paths:
             if path not in known_directories and path_is_included_in_from_mappings(path):
-                files_and_empty_dirs.append(FileInContainer(
-                    container=self._container,
-                    overlay_upper_dir_path=overlay_upper_dir_path,
-                    path_in_container=path,
-                ))
+                files_and_empty_dirs.append(
+                    FileInContainer(
+                        container=self._container,
+                        overlay_upper_dir_path=overlay_upper_dir_path,
+                        path_in_container=path,
+                    )
+                )
 
         return files_and_empty_dirs
 

biolib/compute_node/job_worker/job_storage.py

@@ -10,6 +10,7 @@ from biolib.utils.multipart_uploader import get_chunk_iterator_from_file_object
 
 
 class JobStorage:
+    module_input_file_name = 'input-output.bbf'
     module_output_file_name = 'module-output.bbf'
 
     @staticmethod
@@ -46,8 +47,21 @@ class JobStorage:
         module_output_path = os.path.join(job_temporary_dir, JobStorage.module_output_file_name)
         module_output_size = os.path.getsize(module_output_path)
 
+        # Calculate chunk size based on max chunk count of 10_000, using 9_000 to be on the safe side
+        max_chunk_count = 9_000
+        min_chunk_size_bytes = 50_000_000
+        chunk_size_in_bytes = max(min_chunk_size_bytes, module_output_size // max_chunk_count)
+
+        logger_no_user_data.debug(
+            f'Job "{job_uuid}" uploading result of size {module_output_size} bytes '
+            f'with chunk size of {chunk_size_in_bytes} bytes...'
+        )
+
         with open(module_output_path, mode='rb') as module_output_file:
-            module_output_iterator = get_chunk_iterator_from_file_object(module_output_file)
+            module_output_iterator = get_chunk_iterator_from_file_object(
+                file_object=module_output_file,
+                chunk_size_in_bytes=chunk_size_in_bytes,
+            )
             multipart_uploader = JobStorage._get_module_output_uploader(job_uuid)
             multipart_uploader.upload(
                 payload_iterator=module_output_iterator,
@@ -81,7 +95,7 @@ class JobStorage:
         )
 
     @staticmethod
-    def get_module_input(job: CreatedJobDict) -> bytes:
+    def download_module_input(job: CreatedJobDict, path: str):
         job_uuid = job['public_id']
         logger_no_user_data.debug(f'Job "{job_uuid}" downloading module input...')
         presigned_download_url = BiolibJobApi.get_job_storage_download_url(
@@ -89,7 +103,5 @@ class JobStorage:
             job_auth_token=job['auth_token'],
             storage_type='input',
         )
-        response = HttpClient.request(url=presigned_download_url)
-        data: bytes = response.content
+        HttpClient.request(url=presigned_download_url, response_path=path)
         logger_no_user_data.debug(f'Job "{job_uuid}" module input downloaded')
-        return data

biolib/compute_node/job_worker/job_worker.py

@@ -133,7 +133,8 @@ class JobWorker:
                         ).start()
 
                         try:
-                            module_input_serialized = JobStorage.get_module_input(job=job)
+                            module_input_path = os.path.join(self.job_temporary_dir, JobStorage.module_input_file_name)
+                            JobStorage.download_module_input(job=job, path=module_input_path)
                         except StorageDownloadFailed:
                             # Expect module input to be handled in a separate ModuleInput package
                             self._legacy_input_wait_timeout_thread = JobLegacyInputWaitTimeout(
@@ -147,7 +148,7 @@ class JobWorker:
                             raise error
 
                         try:
-                            self._run_root_job(module_input_serialized)
+                            self._run_root_job(module_input_path)
 
                         # This error occurs when trying to access the container after the job worker has cleaned it up.
                         # In that case stop the computation.
@@ -165,7 +166,9 @@ class JobWorker:
                         self._legacy_input_wait_timeout_thread.stop()
 
                     try:
-                        self._run_root_job(package)
+                        module_input_path = os.path.join(self.job_temporary_dir, JobStorage.module_input_file_name)
+                        open(module_input_path, 'wb').write(package)
+                        self._run_root_job(module_input_path)
 
                     # This error occurs when trying to access the container after the job worker has cleaned it up.
                     # In that case stop the computation.
@@ -250,7 +253,6 @@ class JobWorker:
 
     def _start_network_and_remote_host_proxies(self, job: CreatedJobDict) -> None:
         app_version = job['app_version']
-        app = app_version.get('app', {})
         job_id = job['public_id']
         remote_hosts = app_version['remote_hosts']
         if utils.IS_RUNNING_IN_CLOUD:
@@ -313,7 +315,6 @@ class JobWorker:
                         self._internal_network,
                         job_id,
                         ports,
-                        can_push_data_record_for_user=app.get('can_push_data_record_for_user', False),
                     )
                     remote_host_proxy.start()
                     self._remote_host_proxies.append(remote_host_proxy)
@@ -331,15 +332,15 @@ class JobWorker:
     def _run_app_version(
             self,
             app_version_id: str,
-            module_input_serialized: bytes,
+            module_input_path: str,
             caller_job: CreatedJobDict,
             main_module_output_path: str,
     ) -> None:
         job: CreatedJobDict = BiolibJobApi.create(app_version_id, caller_job=caller_job['public_id'])
         self._jobs[job['public_id']] = job
-        self._run_job(job, module_input_serialized, main_module_output_path)
+        self._run_job(job, module_input_path, main_module_output_path)
 
-    def _run_job(self, job: CreatedJobDict, module_input_serialized: bytes, main_module_output_path: str) -> None:
+    def _run_job(self, job: CreatedJobDict, module_input_path: str, main_module_output_path: str) -> None:
         job_uuid = job['public_id']
         logger_no_user_data.info(f'Job "{job_uuid}" running...')
         if self._root_job_wrapper is None:
@@ -406,7 +407,7 @@ class JobWorker:
                 send_system_exception=self.send_system_exception,
                 send_stdout_and_stderr=self.send_stdout_and_stderr,
             ),
-            module_input_serialized,
+            module_input_path,
             main_module_output_path,
         )
 
@@ -417,15 +418,20 @@ class JobWorker:
     def _run_module(
             self,
             options: LocalExecutorOptions,
-            module_input_serialized: bytes,
+            module_input_path: str,
             module_output_path: str,
     ) -> None:
         module = options['module']
         job_id = options['job']['public_id']
         logger_no_user_data.debug(f'Job "{job_id}" running module "{module["name"]}"...')
+
         executor_instance: DockerExecutor
         if module['environment'] == ModuleEnvironment.BIOLIB_APP.value:
+            if not self.job_temporary_dir:
+                raise BioLibError('Undefined job_temporary_dir')
             logger_no_user_data.debug(f'Job "{job_id}" starting child job...')
+            with open(module_input_path,'rb') as fp:
+                module_input_serialized = fp.read()
             module_input = ModuleInput(module_input_serialized).deserialize()
             module_input_with_runtime_zip = self._add_runtime_zip_and_command_to_module_input(options, module_input)
             module_input_with_runtime_zip_serialized = ModuleInput().serialize(
@@ -433,9 +439,11 @@ class JobWorker:
                 arguments=module_input_with_runtime_zip['arguments'],
                 files=module_input_with_runtime_zip['files'],
             )
+            module_input_path_new = os.path.join(self.job_temporary_dir, "runtime." + JobStorage.module_input_file_name)
+            open(module_input_path_new, 'wb').write(module_input_with_runtime_zip_serialized)
             return self._run_app_version(
                 module['image_uri'],
-                module_input_with_runtime_zip_serialized,
+                module_input_path_new,
                 options['job'],
                 module_output_path,
             )
@@ -461,7 +469,7 @@ class JobWorker:
             # Log memory and disk before pulling and executing module
             log_disk_and_memory_usage_info()
 
-        executor_instance.execute_module(module_input_serialized, module_output_path)
+        executor_instance.execute_module(module_input_path, module_output_path)
 
     def _connect_to_parent(self):
         try:
@@ -587,7 +595,7 @@ class JobWorker:
                 may_contain_user_data=False
             ) from exception
 
-    def _run_root_job(self, module_input_serialized: bytes) -> str:
+    def _run_root_job(self, module_input_path: str) -> str:
         # Make typechecker happy
         if not self._root_job_wrapper or not self.job_temporary_dir:
             raise BioLibError('Undefined job_wrapper or job_temporary_dir')
@@ -595,7 +603,7 @@ class JobWorker:
         main_module_output_path = os.path.join(self.job_temporary_dir, JobStorage.module_output_file_name)
         self._run_job(
             job=self._root_job_wrapper['job'],
-            module_input_serialized=module_input_serialized,
+            module_input_path=module_input_path,
             main_module_output_path=main_module_output_path,
         )
         self._send_status_update(StatusUpdate(progress=94, log_message='Computation finished'))
@@ -614,7 +622,9 @@ class JobWorker:
                     job_temporary_dir=job_temporary_dir,
                 )
                 self._start_network_and_remote_host_proxies(job_dict)
-                module_output_path = self._run_root_job(module_input_serialized)
+                module_input_path = os.path.join(self.job_temporary_dir, JobStorage.module_input_file_name)
+                open(module_input_path, 'wb').write(module_input_serialized)
+                module_output_path = self._run_root_job(module_input_path)
                 with open(module_output_path, mode='rb') as module_output_file:
                     module_output_serialized = module_output_file.read()
                 return ModuleOutputV2(InMemoryIndexableBuffer(module_output_serialized))