code: def run_job(
      self,
      run: Run,
      job: Job,
      instance_offer: InstanceOfferWithAvailability,
      project_ssh_public_key: str,
      project_ssh_private_key: str,
  ) -> LaunchedInstanceInfo:
      cuda = len(instance_offer.instance.resources.gpus) > 0
      security_group_id = self._get_security_group_id(
          project_name=run.project_name
      )
      subnet_id = self._get_subnet_id(zone=instance_offer.region)
      image_id = self._get_image_id(cuda=cuda)
  
      try:
          disk_size = round(
              instance_offer.instance.resources.disk.size_mib / 1024
          )
          resp = self.api_client.compute_instances_create(
              folder_id=self.config.folder_id,
              name=get_instance_name(run, job),
              zone_id=instance_offer.region,
              platform_id=instance_offer.instance.name,
              resources_spec=ResourcesSpec(
                  memory=int(
                      instance_offer.instance.resources.memory_mib
                      * MEGABYTE
                  ),
                  cores=instance_offer.instance.resources.cpus,
                  coreFraction=100,
                  gpus=len(instance_offer.instance.resources.gpus),
              ),
              metadata={
                  "user-data": get_user_data(
                      backend=BackendType.NEBIUS,
                      image_name=job.job_spec.image_name,
                      authorized_keys=[
                          run.run_spec.ssh_key_pub.strip(),
                          project_ssh_public_key.strip(),
                      ],
                      registry_auth_required=job.job_spec.registry_auth
                      is not None,
                  ),
              },
              disk_size_gb=disk_size,
              image_id=image_id,
              subnet_id=subnet_id,
              security_group_ids=[security_group_id],
              labels=self._get_labels(project=run.project_name),
          )
      except ForbiddenError as e:
          if instance_offer.instance.name in e.args[0]:
              raise NoCapacityError(json.loads(e.args[0])["message"])
          raise
      instance_id = resp["metadata"]["instanceId"]
      try:
          while True:
              instance = self.api_client.compute_instances_get(
                  instance_id
              )
              if "primaryV4Address" in instance["networkInterfaces"][0]:
                  break
              time.sleep(INSTANCE_PULL_INTERVAL)
      except Exception:
          self.terminate_instance(instance_id, instance_offer.region)
          raise
      return LaunchedInstanceInfo(
          instance_id=instance_id,
          ip_address=instance["networkInterfaces"][0][
              "primaryV4Address"
          ]["oneToOneNat"]["address"],
          region=instance_offer.region,
          username="ubuntu",
          ssh_port=22,
          dockerized=True,
          backend_data=None,
      )
  
imports: import json
  import re
  import time
  from typing import List, Optional
  import dstack.version
  from dstack._internal import settings
  from dstack._internal.core.backends.base import Compute
  from dstack._internal.core.backends.base.compute import get_instance_name, get_user_data
  from dstack._internal.core.backends.base.offers import get_catalog_offers
  from dstack._internal.core.backends.nebius.api_client import NebiusAPIClient
  from dstack._internal.core.backends.nebius.config import NebiusConfig
  from dstack._internal.core.backends.nebius.types import ForbiddenError, NotFoundError, ResourcesSpec
  from dstack._internal.core.errors import NoCapacityError
  from dstack._internal.core.models.backends.base import BackendType
  from dstack._internal.core.models.instances import InstanceAvailability, InstanceOfferWithAvailability, LaunchedInstanceInfo
  from dstack._internal.core.models.runs import Job, Requirements, Run
label_desc: Use image node_id 3 for calling the NebiusCompute obj's underlying member method code with example usage: obj.run_job(run, job, instance_offer, project_ssh_public_key, project_ssh_private_key) and returns: LaunchedInstanceInfo