dstack 0.19.1__tar.gz → 0.19.2__tar.gz

{dstack-0.19.1 → dstack-0.19.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dstack
-Version: 0.19.1
+Version: 0.19.2
 Summary: dstack is an open-source orchestration engine for running AI workloads on any cloud or on-premises.
 Home-page: https://dstack.ai
 Author: Andrey Cheptsov
@@ -25,6 +25,7 @@ Provides-Extra: datacrunch
 Provides-Extra: gcp
 Provides-Extra: kubernetes
 Provides-Extra: lambda
+Provides-Extra: nebius
 Provides-Extra: oci
 License-File: LICENSE.md
 

{dstack-0.19.1 → dstack-0.19.2}/setup.py

@@ -34,6 +34,7 @@ BASE_DEPS = [
     "cryptography",
     "packaging",
     "python-dateutil",
+    "cachetools",
     "gitpython",
     "jsonschema",
     "paramiko>=3.2.0",
@@ -48,7 +49,7 @@ BASE_DEPS = [
     "python-multipart>=0.0.16",
     "filelock",
     "psutil",
-    "gpuhunt>=0.1.0,<0.2.0",
+    "gpuhunt>=0.1.1,<0.2.0",
     "argcomplete>=3.5.0",
 ]
 
@@ -74,7 +75,6 @@ SERVER_DEPS = GATEWAY_AND_SERVER_COMMON_DEPS + [
     "sentry-sdk[fastapi]",
     "alembic-postgresql-enum",
     "asyncpg",
-    "cachetools",
     "python-json-logger>=3.1.0",
     "prometheus-client",
     "grpcio>=1.50",  # indirect
@@ -110,10 +110,23 @@ KUBERNETES_DEPS = ["kubernetes"]
 
 LAMBDA_DEPS = AWS_DEPS
 
+# Nebius requires Python 3.10. On 3.9:
+# `pip install dstack[nebius]` is expected to fail
+# `pip install dstack[all]` is expected to ignore Nebius
+NEBIUS_DEPS = ["nebius>=0.2.19,<0.3"]
+MAYBE_NEBIUS_DEPS = ['nebius>=0.2.19,<0.3; python_version>="3.10"']
+
 OCI_DEPS = ["oci"]
 
 ALL_DEPS = (
-    SERVER_DEPS + AWS_DEPS + AZURE_DEPS + GCP_DEPS + DATACRUNCH_DEPS + KUBERNETES_DEPS + OCI_DEPS
+    SERVER_DEPS
+    + AWS_DEPS
+    + AZURE_DEPS
+    + GCP_DEPS
+    + DATACRUNCH_DEPS
+    + KUBERNETES_DEPS
+    + MAYBE_NEBIUS_DEPS
+    + OCI_DEPS
 )
 
 setup(
@@ -155,6 +168,7 @@ setup(
         "gcp": SERVER_DEPS + GCP_DEPS,
         "kubernetes": SERVER_DEPS + KUBERNETES_DEPS,
         "lambda": SERVER_DEPS + LAMBDA_DEPS,
+        "nebius": SERVER_DEPS + NEBIUS_DEPS,
         "oci": SERVER_DEPS + OCI_DEPS,
     },
     classifiers=[

dstack-0.19.1/src/dstack/_internal/cli/commands/stats.py → dstack-0.19.2/src/dstack/_internal/cli/commands/metrics.py

@@ -14,14 +14,15 @@ from dstack._internal.cli.utils.common import (
     console,
 )
 from dstack._internal.core.errors import CLIError
+from dstack._internal.core.models.instances import Resources
 from dstack._internal.core.models.metrics import JobMetrics
 from dstack.api._public import Client
 from dstack.api._public.runs import Run
 
 
-class StatsCommand(APIBaseCommand):
-    NAME = "stats"
-    DESCRIPTION = "Show run stats"
+class MetricsCommand(APIBaseCommand):
+    NAME = "metrics"
+    DESCRIPTION = "Show run metrics"
 
     def _register(self):
         super()._register()
@@ -29,7 +30,7 @@ class StatsCommand(APIBaseCommand):
         self._parser.add_argument(
             "-w",
             "--watch",
-            help="Watch run stats in realtime",
+            help="Watch run metrics in realtime",
             action="store_true",
         )
 
@@ -43,13 +44,13 @@ class StatsCommand(APIBaseCommand):
         metrics = _get_run_jobs_metrics(api=self.api, run=run)
 
         if not args.watch:
-            console.print(_get_stats_table(run, metrics))
+            console.print(_get_metrics_table(run, metrics))
             return
 
         try:
             with Live(console=console, refresh_per_second=LIVE_TABLE_REFRESH_RATE_PER_SEC) as live:
                 while True:
-                    live.update(_get_stats_table(run, metrics))
+                    live.update(_get_metrics_table(run, metrics))
                     time.sleep(LIVE_TABLE_PROVISION_INTERVAL_SECS)
                     run = self.api.runs.get(run_name=args.run_name)
                     if run is None:
@@ -74,7 +75,7 @@ def _get_run_jobs_metrics(api: Client, run: Run) -> List[JobMetrics]:
     return metrics
 
 
-def _get_stats_table(run: Run, metrics: List[JobMetrics]) -> Table:
+def _get_metrics_table(run: Run, metrics: List[JobMetrics]) -> Table:
     table = Table(box=None)
     table.add_column("NAME", style="bold", no_wrap=True)
     table.add_column("CPU")
@@ -86,15 +87,24 @@ def _get_stats_table(run: Run, metrics: List[JobMetrics]) -> Table:
         add_row_from_dict(table, run_row)
 
     for job, job_metrics in zip(run._run.jobs, metrics):
+        jrd = job.job_submissions[-1].job_runtime_data
+        jpd = job.job_submissions[-1].job_provisioning_data
+        resources: Optional[Resources] = None
+        if jrd is not None and jrd.offer is not None:
+            resources = jrd.offer.instance.resources
+        elif jpd is not None:
+            resources = jpd.instance_type.resources
         cpu_usage = _get_metric_value(job_metrics, "cpu_usage_percent")
         if cpu_usage is not None:
-            cpu_usage = f"{cpu_usage}%"
+            if resources is not None:
+                cpu_usage = cpu_usage / resources.cpus
+            cpu_usage = f"{cpu_usage:.0f}%"
         memory_usage = _get_metric_value(job_metrics, "memory_working_set_bytes")
         if memory_usage is not None:
             memory_usage = f"{round(memory_usage / 1024 / 1024)}MB"
-            if job.job_submissions[-1].job_provisioning_data is not None:
-                memory_usage += f"/{job.job_submissions[-1].job_provisioning_data.instance_type.resources.memory_mib}MB"
-        gpu_stats = ""
+            if resources is not None:
+                memory_usage += f"/{resources.memory_mib}MB"
+        gpu_metrics = ""
         gpus_detected_num = _get_metric_value(job_metrics, "gpus_detected_num")
         if gpus_detected_num is not None:
             for i in range(gpus_detected_num):
@@ -102,17 +112,17 @@ def _get_stats_table(run: Run, metrics: List[JobMetrics]) -> Table:
                 gpu_util_percent = _get_metric_value(job_metrics, f"gpu_util_percent_gpu{i}")
                 if gpu_memory_usage is not None:
                     if i != 0:
-                        gpu_stats += "\n"
-                    gpu_stats += f"#{i} {round(gpu_memory_usage / 1024 / 1024)}MB"
-                    if job.job_submissions[-1].job_provisioning_data is not None:
-                        gpu_stats += f"/{job.job_submissions[-1].job_provisioning_data.instance_type.resources.gpus[i].memory_mib}MB"
-                    gpu_stats += f" {gpu_util_percent}% Util"
+                        gpu_metrics += "\n"
+                    gpu_metrics += f"#{i} {round(gpu_memory_usage / 1024 / 1024)}MB"
+                    if resources is not None:
+                        gpu_metrics += f"/{resources.gpus[i].memory_mib}MB"
+                    gpu_metrics += f" {gpu_util_percent}% Util"
 
         job_row: Dict[Union[str, int], Any] = {
             "NAME": f"  replica={job.job_spec.replica_num} job={job.job_spec.job_num}",
             "CPU": cpu_usage or "-",
             "MEMORY": memory_usage or "-",
-            "GPU": gpu_stats or "-",
+            "GPU": gpu_metrics or "-",
         }
         if len(run._run.jobs) == 1:
             job_row.update(run_row)

dstack-0.19.2/src/dstack/_internal/cli/commands/stats.py

@@ -0,0 +1,14 @@
+import argparse
+
+from dstack._internal.cli.commands.metrics import MetricsCommand
+from dstack._internal.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class StatsCommand(MetricsCommand):
+    NAME = "stats"
+
+    def _command(self, args: argparse.Namespace):
+        logger.warning("`dstack stats` is deprecated in favor of `dstack metrics`")
+        super()._command(args)

{dstack-0.19.1 → dstack-0.19.2}/src/dstack/_internal/cli/main.py

@@ -13,6 +13,7 @@ from dstack._internal.cli.commands.fleet import FleetCommand
 from dstack._internal.cli.commands.gateway import GatewayCommand
 from dstack._internal.cli.commands.init import InitCommand
 from dstack._internal.cli.commands.logs import LogsCommand
+from dstack._internal.cli.commands.metrics import MetricsCommand
 from dstack._internal.cli.commands.ps import PsCommand
 from dstack._internal.cli.commands.server import ServerCommand
 from dstack._internal.cli.commands.stats import StatsCommand
@@ -65,6 +66,7 @@ def main():
     GatewayCommand.register(subparsers)
     InitCommand.register(subparsers)
     LogsCommand.register(subparsers)
+    MetricsCommand.register(subparsers)
     PsCommand.register(subparsers)
     ServerCommand.register(subparsers)
     StatsCommand.register(subparsers)

{dstack-0.19.1 → dstack-0.19.2}/src/dstack/_internal/core/backends/base/compute.py

@@ -94,6 +94,9 @@ class Compute(ABC):
         """
         Terminates an instance by `instance_id`.
         If the instance does not exist, it should not raise errors but return silently.
+
+        Should return ASAP. If required to wait for some operation, raise `NotYetTerminated`.
+        In this case, the method will be called again after a few seconds.
         """
         pass
 

dstack-0.19.2/src/dstack/_internal/core/backends/base/models.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+
+def fill_data(values: dict, filename_field: str = "filename", data_field: str = "data") -> dict:
+    if values.get(data_field) is not None:
+        return values
+    if (filename := values.get(filename_field)) is None:
+        raise ValueError(f"Either `{filename_field}` or `{data_field}` must be specified")
+    try:
+        with open(Path(filename).expanduser()) as f:
+            values[data_field] = f.read()
+    except OSError:
+        raise ValueError(f"No such file {filename}")
+    return values

{dstack-0.19.1 → dstack-0.19.2}/src/dstack/_internal/core/backends/configurators.py

@@ -63,6 +63,15 @@ try:
 except ImportError:
     pass
 
+try:
+    from dstack._internal.core.backends.nebius.configurator import (
+        NebiusConfigurator,
+    )
+
+    _CONFIGURATOR_CLASSES.append(NebiusConfigurator)
+except ImportError:
+    pass
+
 try:
     from dstack._internal.core.backends.oci.configurator import OCIConfigurator
 

{dstack-0.19.1 → dstack-0.19.2}/src/dstack/_internal/core/backends/models.py

@@ -34,6 +34,11 @@ from dstack._internal.core.backends.lambdalabs.models import (
     LambdaBackendConfig,
     LambdaBackendConfigWithCreds,
 )
+from dstack._internal.core.backends.nebius.models import (
+    NebiusBackendConfig,
+    NebiusBackendConfigWithCreds,
+    NebiusBackendFileConfigWithCreds,
+)
 from dstack._internal.core.backends.oci.models import (
     OCIBackendConfig,
     OCIBackendConfigWithCreds,
@@ -65,6 +70,7 @@ AnyBackendConfigWithoutCreds = Union[
     GCPBackendConfig,
     KubernetesBackendConfig,
     LambdaBackendConfig,
+    NebiusBackendConfig,
     OCIBackendConfig,
     RunpodBackendConfig,
     TensorDockBackendConfig,
@@ -86,6 +92,7 @@ AnyBackendConfigWithCreds = Union[
     KubernetesBackendConfigWithCreds,
     LambdaBackendConfigWithCreds,
     OCIBackendConfigWithCreds,
+    NebiusBackendConfigWithCreds,
     RunpodBackendConfigWithCreds,
     TensorDockBackendConfigWithCreds,
     VastAIBackendConfigWithCreds,
@@ -105,6 +112,7 @@ AnyBackendFileConfigWithCreds = Union[
     KubernetesBackendFileConfigWithCreds,
     LambdaBackendConfigWithCreds,
     OCIBackendConfigWithCreds,
+    NebiusBackendFileConfigWithCreds,
     RunpodBackendConfigWithCreds,
     TensorDockBackendConfigWithCreds,
     VastAIBackendConfigWithCreds,

dstack-0.19.2/src/dstack/_internal/core/backends/nebius/backend.py

@@ -0,0 +1,16 @@
+from dstack._internal.core.backends.base.backend import Backend
+from dstack._internal.core.backends.nebius.compute import NebiusCompute
+from dstack._internal.core.backends.nebius.models import NebiusConfig
+from dstack._internal.core.models.backends.base import BackendType
+
+
+class NebiusBackend(Backend):
+    TYPE = BackendType.NEBIUS
+    COMPUTE_CLASS = NebiusCompute
+
+    def __init__(self, config: NebiusConfig):
+        self.config = config
+        self._compute = NebiusCompute(self.config)
+
+    def compute(self) -> NebiusCompute:
+        return self._compute

dstack-0.19.2/src/dstack/_internal/core/backends/nebius/compute.py

@@ -0,0 +1,270 @@
+import json
+import shlex
+import time
+from functools import cached_property
+from typing import List, Optional
+
+from nebius.aio.operation import Operation as SDKOperation
+from nebius.aio.service_error import RequestError, StatusCode
+from nebius.api.nebius.common.v1 import Operation
+from nebius.sdk import SDK
+
+from dstack._internal.core.backends.base.backend import Compute
+from dstack._internal.core.backends.base.compute import (
+    ComputeWithCreateInstanceSupport,
+    ComputeWithMultinodeSupport,
+    generate_unique_instance_name,
+    get_user_data,
+)
+from dstack._internal.core.backends.base.offers import get_catalog_offers
+from dstack._internal.core.backends.nebius import resources
+from dstack._internal.core.backends.nebius.models import NebiusConfig, NebiusServiceAccountCreds
+from dstack._internal.core.errors import BackendError, NotYetTerminated, ProvisioningError
+from dstack._internal.core.models.backends.base import BackendType
+from dstack._internal.core.models.common import CoreModel
+from dstack._internal.core.models.instances import (
+    InstanceAvailability,
+    InstanceConfiguration,
+    InstanceOffer,
+    InstanceOfferWithAvailability,
+)
+from dstack._internal.core.models.resources import Memory, Range
+from dstack._internal.core.models.runs import JobProvisioningData, Requirements
+from dstack._internal.utils.logging import get_logger
+
+logger = get_logger(__name__)
+CONFIGURABLE_DISK_SIZE = Range[Memory](
+    min=Memory.parse("40GB"),  # min for the ubuntu22.04-cuda12 image
+    max=Memory.parse("8192GB"),  # max for the NETWORK_SSD disk type
+)
+WAIT_FOR_DISK_TIMEOUT = 20
+WAIT_FOR_INSTANCE_TIMEOUT = 30
+WAIT_FOR_INSTANCE_UPDATE_INTERVAL = 2.5
+DELETE_INSTANCE_TIMEOUT = 25
+DOCKER_DAEMON_CONFIG = {
+    "runtimes": {"nvidia": {"args": [], "path": "nvidia-container-runtime"}},
+    # Workaround for https://github.com/NVIDIA/nvidia-container-toolkit/issues/48
+    "exec-opts": ["native.cgroupdriver=cgroupfs"],
+}
+SETUP_COMMANDS = [
+    "ufw allow ssh",
+    "ufw allow from 192.168.0.0/16",
+    "ufw default deny incoming",
+    "ufw default allow outgoing",
+    "ufw enable",
+    'sed -i "s/.*AllowTcpForwarding.*/AllowTcpForwarding yes/g" /etc/ssh/sshd_config',
+    "service ssh restart",
+    f"echo {shlex.quote(json.dumps(DOCKER_DAEMON_CONFIG))} > /etc/docker/daemon.json",
+    "service docker restart",
+]
+SUPPORTED_PLATFORMS = [
+    "gpu-h100-sxm",
+    "gpu-h200-sxm",
+    "gpu-l40s-a",
+    "gpu-l40s-d",
+    "cpu-d3",
+    "cpu-e2",
+]
+
+
+class NebiusCompute(
+    ComputeWithCreateInstanceSupport,
+    ComputeWithMultinodeSupport,
+    Compute,
+):
+    def __init__(self, config: NebiusConfig):
+        super().__init__()
+        self.config = config
+        self._subnet_id_cache: dict[str, str] = {}
+
+    @cached_property
+    def _sdk(self) -> SDK:
+        assert isinstance(self.config.creds, NebiusServiceAccountCreds)
+        return resources.make_sdk(self.config.creds)
+
+    @cached_property
+    def _region_to_project_id(self) -> dict[str, str]:
+        return resources.get_region_to_project_id_map(self._sdk)
+
+    def _get_subnet_id(self, region: str) -> str:
+        if region not in self._subnet_id_cache:
+            self._subnet_id_cache[region] = resources.get_default_subnet(
+                self._sdk, self._region_to_project_id[region]
+            ).metadata.id
+        return self._subnet_id_cache[region]
+
+    def get_offers(
+        self, requirements: Optional[Requirements] = None
+    ) -> List[InstanceOfferWithAvailability]:
+        offers = get_catalog_offers(
+            backend=BackendType.NEBIUS,
+            locations=self.config.regions or list(self._region_to_project_id),
+            requirements=requirements,
+            extra_filter=_supported_instances,
+            configurable_disk_size=CONFIGURABLE_DISK_SIZE,
+        )
+        return [
+            InstanceOfferWithAvailability(
+                **offer.dict(),
+                availability=InstanceAvailability.UNKNOWN,
+            )
+            for offer in offers
+        ]
+
+    def create_instance(
+        self,
+        instance_offer: InstanceOfferWithAvailability,
+        instance_config: InstanceConfiguration,
+    ) -> JobProvisioningData:
+        # NOTE: This method can block for a long time as it waits for the boot disk to be created
+        # and the instance to enter the STARTING state. This has to be done in create_instance so
+        # that we can handle quota and availability errors that may occur even after creating an
+        # instance.
+        instance_name = generate_unique_instance_name(instance_config)
+        platform, preset = instance_offer.instance.name.split()
+        create_disk_op = resources.create_disk(
+            sdk=self._sdk,
+            name=instance_name,
+            project_id=self._region_to_project_id[instance_offer.region],
+            size_mib=instance_offer.instance.resources.disk.size_mib,
+            image_family="ubuntu22.04-cuda12",
+        )
+        create_instance_op = None
+        try:
+            logger.debug("Blocking until disk %s is created", create_disk_op.resource_id)
+            resources.wait_for_operation(create_disk_op, timeout=WAIT_FOR_DISK_TIMEOUT)
+            if not create_disk_op.successful():
+                raw_op = create_disk_op.raw()
+                raise ProvisioningError(
+                    f"Create disk operation failed. Message: {raw_op.status.message}."
+                    f" Details: {raw_op.status.details}"
+                )
+            create_instance_op = resources.create_instance(
+                sdk=self._sdk,
+                name=instance_name,
+                project_id=self._region_to_project_id[instance_offer.region],
+                user_data=get_user_data(
+                    instance_config.get_public_keys(),
+                    backend_specific_commands=SETUP_COMMANDS,
+                ),
+                platform=platform,
+                preset=preset,
+                disk_id=create_disk_op.resource_id,
+                subnet_id=self._get_subnet_id(instance_offer.region),
+            )
+            _wait_for_instance(self._sdk, create_instance_op)
+        except BaseException:
+            if create_instance_op is not None:
+                try:
+                    with resources.ignore_errors([StatusCode.NOT_FOUND]):
+                        delete_instance_op = resources.delete_instance(
+                            self._sdk, create_instance_op.resource_id
+                        )
+                    resources.wait_for_operation(
+                        delete_instance_op, timeout=DELETE_INSTANCE_TIMEOUT
+                    )
+                except Exception as e:
+                    logger.exception(
+                        "Could not delete instance %s: %s", create_instance_op.resource_id, e
+                    )
+            try:
+                with resources.ignore_errors([StatusCode.NOT_FOUND]):
+                    resources.delete_disk(self._sdk, create_disk_op.resource_id)
+            except Exception as e:
+                logger.exception(
+                    "Could not delete boot disk %s: %s", create_disk_op.resource_id, e
+                )
+            raise
+        return JobProvisioningData(
+            backend=instance_offer.backend,
+            instance_type=instance_offer.instance,
+            instance_id=create_instance_op.resource_id,
+            hostname=None,
+            region=instance_offer.region,
+            price=instance_offer.price,
+            ssh_port=22,
+            username="ubuntu",
+            dockerized=True,
+            backend_data=NebiusInstanceBackendData(boot_disk_id=create_disk_op.resource_id).json(),
+        )
+
+    def update_provisioning_data(
+        self, provisioning_data, project_ssh_public_key, project_ssh_private_key
+    ):
+        instance = resources.get_instance(self._sdk, provisioning_data.instance_id)
+        if not instance.status.network_interfaces:
+            return
+        interface = instance.status.network_interfaces[0]
+        provisioning_data.hostname, _ = interface.public_ip_address.address.split("/")
+        provisioning_data.internal_ip, _ = interface.ip_address.address.split("/")
+
+    def terminate_instance(
+        self, instance_id: str, region: str, backend_data: Optional[str] = None
+    ):
+        backend_data_parsed = NebiusInstanceBackendData.load(backend_data)
+        try:
+            instance = resources.get_instance(self._sdk, instance_id)
+        except RequestError as e:
+            if e.status.code != StatusCode.NOT_FOUND:
+                raise
+            instance = None
+        if instance is not None:
+            if instance.status.state != instance.status.InstanceState.DELETING:
+                resources.delete_instance(self._sdk, instance_id)
+                raise NotYetTerminated(
+                    "Requested instance deletion."
+                    " Will wait for deletion before deleting the boot disk."
+                    f" Instance state was: {instance.status.state.name}"
+                )
+            else:
+                raise NotYetTerminated(
+                    "Waiting for instance deletion before deleting the boot disk."
+                    f" Instance state: {instance.status.state.name}"
+                )
+        with resources.ignore_errors([StatusCode.NOT_FOUND]):
+            resources.delete_disk(self._sdk, backend_data_parsed.boot_disk_id)
+
+
+class NebiusInstanceBackendData(CoreModel):
+    boot_disk_id: str
+
+    @classmethod
+    def load(cls, raw: Optional[str]) -> "NebiusInstanceBackendData":
+        assert raw is not None
+        return cls.__response__.parse_raw(raw)
+
+
+def _wait_for_instance(sdk: SDK, op: SDKOperation[Operation]) -> None:
+    start = time.monotonic()
+    while True:
+        if op.done() and not op.successful():
+            raise ProvisioningError(
+                f"Create instance operation failed. Message: {op.raw().status.message}."
+                f" Details: {op.raw().status.details}"
+            )
+        instance = resources.get_instance(sdk, op.resource_id)
+        if instance.status.state in [
+            instance.status.InstanceState.STARTING,
+            instance.status.InstanceState.RUNNING,
+        ]:
+            break
+        if time.monotonic() - start > WAIT_FOR_INSTANCE_TIMEOUT:
+            raise BackendError(
+                f"Instance {instance.metadata.id} did not start booting in time."
+                f" Status: {instance.status.state.name}"
+            )
+        logger.debug(
+            "Waiting for instance %s. Status: %s. Operation status: %s",
+            instance.metadata.name,
+            instance.status.state.name,
+            op.status(),
+        )
+        time.sleep(WAIT_FOR_INSTANCE_UPDATE_INTERVAL)
+        resources.LOOP.await_(
+            op.update(timeout=resources.REQUEST_TIMEOUT, metadata=resources.REQUEST_MD)
+        )
+
+
+def _supported_instances(offer: InstanceOffer) -> bool:
+    platform, _ = offer.instance.name.split()
+    return platform in SUPPORTED_PLATFORMS and not offer.instance.resources.spot

dstack-0.19.2/src/dstack/_internal/core/backends/nebius/configurator.py

@@ -0,0 +1,74 @@
+import json
+
+from nebius.aio.service_error import RequestError
+
+from dstack._internal.core.backends.base.configurator import (
+    BackendRecord,
+    Configurator,
+    raise_invalid_credentials_error,
+)
+from dstack._internal.core.backends.nebius import resources
+from dstack._internal.core.backends.nebius.backend import NebiusBackend
+from dstack._internal.core.backends.nebius.models import (
+    AnyNebiusBackendConfig,
+    NebiusBackendConfig,
+    NebiusBackendConfigWithCreds,
+    NebiusConfig,
+    NebiusCreds,
+    NebiusServiceAccountCreds,
+    NebiusStoredConfig,
+)
+from dstack._internal.core.models.backends.base import BackendType
+
+
+class NebiusConfigurator(Configurator):
+    TYPE = BackendType.NEBIUS
+    BACKEND_CLASS = NebiusBackend
+
+    def validate_config(self, config: NebiusBackendConfigWithCreds, default_creds_enabled: bool):
+        assert isinstance(config.creds, NebiusServiceAccountCreds)
+        try:
+            sdk = resources.make_sdk(config.creds)
+            available_regions = set(resources.get_region_to_project_id_map(sdk))
+        except (ValueError, RequestError) as e:
+            raise_invalid_credentials_error(
+                fields=[["creds"]],
+                details=str(e),
+            )
+        if invalid_regions := set(config.regions or []) - available_regions:
+            raise_invalid_credentials_error(
+                fields=[["regions"]],
+                details=(
+                    f"Configured regions {invalid_regions} do not exist in this Nebius tenancy."
+                    " Omit `regions` to use all regions or select some of the available regions:"
+                    f" {available_regions}"
+                ),
+            )
+
+    def create_backend(
+        self, project_name: str, config: NebiusBackendConfigWithCreds
+    ) -> BackendRecord:
+        return BackendRecord(
+            config=NebiusStoredConfig(
+                **NebiusBackendConfig.__response__.parse_obj(config).dict()
+            ).json(),
+            auth=NebiusCreds.parse_obj(config.creds).json(),
+        )
+
+    def get_backend_config(
+        self, record: BackendRecord, include_creds: bool
+    ) -> AnyNebiusBackendConfig:
+        config = self._get_config(record)
+        if include_creds:
+            return NebiusBackendConfigWithCreds.__response__.parse_obj(config)
+        return NebiusBackendConfig.__response__.parse_obj(config)
+
+    def get_backend(self, record: BackendRecord) -> NebiusBackend:
+        config = self._get_config(record)
+        return NebiusBackend(config=config)
+
+    def _get_config(self, record: BackendRecord) -> NebiusConfig:
+        return NebiusConfig.__response__(
+            **json.loads(record.config),
+            creds=NebiusCreds.parse_raw(record.auth),
+        )