dstack 0.19.30__py3-none-any.whl → 0.19.31__py3-none-any.whl

dstack/_internal/core/backends/kubernetes/models.py

@@ -5,12 +5,14 @@ from pydantic import Field, root_validator
 from dstack._internal.core.backends.base.models import fill_data
 from dstack._internal.core.models.common import CoreModel
 
+DEFAULT_NAMESPACE = "default"
 
-class KubernetesNetworkingConfig(CoreModel):
-    ssh_host: Annotated[
-        Optional[str], Field(description="The external IP address of any node")
+
+class KubernetesProxyJumpConfig(CoreModel):
+    hostname: Annotated[
+        Optional[str], Field(description="The external IP address or hostname of any node")
     ] = None
-    ssh_port: Annotated[
+    port: Annotated[
         Optional[int], Field(description="Any port accessible outside of the cluster")
     ] = None
 
@@ -22,16 +24,15 @@ class KubeconfigConfig(CoreModel):
 
 class KubernetesBackendConfig(CoreModel):
     type: Annotated[Literal["kubernetes"], Field(description="The type of backend")] = "kubernetes"
-    networking: Annotated[
-        Optional[KubernetesNetworkingConfig], Field(description="The networking configuration")
+    proxy_jump: Annotated[
+        Optional[KubernetesProxyJumpConfig], Field(description="The SSH proxy jump configuration")
     ] = None
+    namespace: Annotated[
+        str, Field(description="The namespace for resources managed by `dstack`")
+    ] = DEFAULT_NAMESPACE
 
 
-class KubernetesBackendConfigWithCreds(CoreModel):
-    type: Annotated[Literal["kubernetes"], Field(description="The type of backend")] = "kubernetes"
-    networking: Annotated[
-        Optional[KubernetesNetworkingConfig], Field(description="The networking configuration")
-    ] = None
+class KubernetesBackendConfigWithCreds(KubernetesBackendConfig):
     kubeconfig: Annotated[KubeconfigConfig, Field(description="The kubeconfig configuration")]
 
 
@@ -53,11 +54,7 @@ class KubeconfigFileConfig(CoreModel):
         return fill_data(values)
 
 
-class KubernetesBackendFileConfigWithCreds(CoreModel):
-    type: Annotated[Literal["kubernetes"], Field(description="The type of backend")] = "kubernetes"
-    networking: Annotated[
-        Optional[KubernetesNetworkingConfig], Field(description="The networking configuration")
-    ] = None
+class KubernetesBackendFileConfigWithCreds(KubernetesBackendConfig):
     kubeconfig: Annotated[KubeconfigFileConfig, Field(description="The kubeconfig configuration")]
 
 

dstack/_internal/core/backends/kubernetes/utils.py

@@ -1,20 +1,157 @@
-from typing import Dict, List, Optional
+import ast
+from typing import Any, Callable, List, Literal, Optional, TypeVar, Union, get_origin, overload
 
-import kubernetes
 import yaml
+from kubernetes import client as kubernetes_client
+from kubernetes import config as kubernetes_config
+from typing_extensions import ParamSpec
 
+T = TypeVar("T")
+P = ParamSpec("P")
 
-def get_api_from_config_data(kubeconfig_data: str) -> kubernetes.client.CoreV1Api:
+
+def get_api_from_config_data(kubeconfig_data: str) -> kubernetes_client.CoreV1Api:
     config_dict = yaml.load(kubeconfig_data, yaml.FullLoader)
     return get_api_from_config_dict(config_dict)
 
 
-def get_api_from_config_dict(kubeconfig: Dict) -> kubernetes.client.CoreV1Api:
-    api_client = kubernetes.config.new_client_from_config_dict(config_dict=kubeconfig)
-    return kubernetes.client.CoreV1Api(api_client=api_client)
+def get_api_from_config_dict(kubeconfig: dict) -> kubernetes_client.CoreV1Api:
+    api_client = kubernetes_config.new_client_from_config_dict(config_dict=kubeconfig)
+    return kubernetes_client.CoreV1Api(api_client=api_client)
+
+
+@overload
+def call_api_method(
+    method: Callable[P, Any],
+    type_: type[T],
+    expected: None = None,
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> T: ...
+
+
+@overload
+def call_api_method(
+    method: Callable[P, Any],
+    type_: type[T],
+    expected: Union[int, tuple[int, ...], list[int]],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> Optional[T]: ...
+
+
+def call_api_method(
+    method: Callable[P, Any],
+    type_: type[T],
+    expected: Optional[Union[int, tuple[int, ...], list[int]]] = None,
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> Optional[T]:
+    """
+    Returns the result of the API method call, optionally ignoring specified HTTP status codes.
+
+    Args:
+        method: the `CoreV1Api` bound method.
+        type_: The expected type of the return value, used for runtime type checking and
+            as a type hint for a static type checker (as kubernetes package is not type-annotated).
+            NB: For composite types, only "origin" type is checked, e.g., list, not list[Node]
+        expected: Expected error statuses, e.g., 404.
+        args: positional arguments of the method.
+        kwargs: keyword arguments of the method.
+    Returns:
+        The return value or `None` in case of the expected error.
+    """
+    if isinstance(expected, int):
+        expected = (expected,)
+    result: T
+    try:
+        result = method(*args, **kwargs)
+    except kubernetes_client.ApiException as e:
+        if expected is None or e.status not in expected:
+            raise
+        return None
+    if not isinstance(result, get_origin(type_) or type_):
+        raise TypeError(
+            f"{method.__name__} returned {type(result).__name__}, expected {type_.__name__}"
+        )
+    return result
+
+
+@overload
+def get_value(
+    obj: object, path: str, type_: type[T], *, required: Literal[False] = False
+) -> Optional[T]: ...
+
+
+@overload
+def get_value(obj: object, path: str, type_: type[T], *, required: Literal[True]) -> T: ...
+
+
+def get_value(obj: object, path: str, type_: type[T], *, required: bool = False) -> Optional[T]:
+    """
+    Returns the value at a given path.
+    Supports object attributes, sequence indices, and mapping keys.
+
+    Args:
+        obj: The object to traverse.
+        path: The path to the value, regular Python syntax. The leading dot is optional, all the
+            following are correct: `.attr`, `attr`, `.[0]`, `[0]`, `.['key']`, `['key']`.
+        type_: The expected type of the value, used for runtime type checking and as a type hint
+            for a static type checker (as kubernetes package is not type-annotated).
+            NB: For composite types, only "origin" type is checked, e.g., list, not list[Node]
+        required: If `True`, the value must exist and must not be `None`. If `False` (safe
+            navigation mode), the may not exist and may be `None`.
+
+    Returns:
+        The requested value or `None` in case of failed traverse when required=False.
+    """
+    _path = path.removeprefix(".")
+    if _path.startswith("["):
+        src = f"obj{_path}"
+    else:
+        src = f"obj.{_path}"
+    module = ast.parse(src)
+    assert len(module.body) == 1, ast.dump(module, indent=4)
+    root_expr = module.body[0]
+    assert isinstance(root_expr, ast.Expr), ast.dump(module, indent=4)
+    varname: Optional[str] = None
+    expr = root_expr.value
+    while True:
+        if isinstance(expr, ast.Name):
+            varname = expr.id
+            break
+        if __debug__:
+            if isinstance(expr, ast.Subscript):
+                if isinstance(expr.slice, ast.UnaryOp):
+                    # .items[-1]
+                    assert isinstance(expr.slice.op, ast.USub), ast.dump(expr, indent=4)
+                    assert isinstance(expr.slice.operand, ast.Constant), ast.dump(expr, indent=4)
+                    assert isinstance(expr.slice.operand.value, int), ast.dump(expr, indent=4)
+                else:
+                    # .items[0], .labels["name"]
+                    assert isinstance(expr.slice, ast.Constant), ast.dump(expr, indent=4)
+            else:
+                assert isinstance(expr, ast.Attribute), ast.dump(expr, indent=4)
+        else:
+            assert isinstance(expr, (ast.Attribute, ast.Subscript))
+        expr = expr.value
+    assert varname is not None, ast.dump(module)
+    try:
+        value = eval(src, {"__builtins__": {}}, {"obj": obj})
+    except (AttributeError, KeyError, IndexError, TypeError) as e:
+        if required:
+            raise type(e)(f"Failed to traverse {path}: {e}") from e
+        return None
+    if value is None:
+        if required:
+            raise TypeError(f"Required {path} is None")
+        return value
+    if not isinstance(value, get_origin(type_) or type_):
+        raise TypeError(f"{path} value is {type(value).__name__}, expected {type_.__name__}")
+    return value
 
 
-def get_cluster_public_ip(api_client: kubernetes.client.CoreV1Api) -> Optional[str]:
+def get_cluster_public_ip(api_client: kubernetes_client.CoreV1Api) -> Optional[str]:
     """
     Returns public IP of any cluster node.
     """
@@ -24,7 +161,7 @@ def get_cluster_public_ip(api_client: kubernetes.client.CoreV1Api) -> Optional[s
     return public_ips[0]
 
 
-def get_cluster_public_ips(api_client: kubernetes.client.CoreV1Api) -> List[str]:
+def get_cluster_public_ips(api_client: kubernetes_client.CoreV1Api) -> List[str]:
     """
     Returns public IPs of all cluster nodes.
     """

dstack/_internal/core/backends/lambdalabs/compute.py

@@ -9,6 +9,7 @@ from dstack._internal.core.backends.base.compute import (
     Compute,
     ComputeWithAllOffersCached,
     ComputeWithCreateInstanceSupport,
+    ComputeWithPrivilegedSupport,
     generate_unique_instance_name,
     get_shim_commands,
 )
@@ -31,6 +32,7 @@ MAX_INSTANCE_NAME_LEN = 60
 class LambdaCompute(
     ComputeWithAllOffersCached,
     ComputeWithCreateInstanceSupport,
+    ComputeWithPrivilegedSupport,
     Compute,
 ):
     def __init__(self, config: LambdaConfig):

dstack/_internal/core/backends/local/compute.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 from dstack._internal.core.backends.base.compute import (
     Compute,
     ComputeWithCreateInstanceSupport,
+    ComputeWithPrivilegedSupport,
     ComputeWithVolumeSupport,
 )
 from dstack._internal.core.consts import DSTACK_RUNNER_SSH_PORT
@@ -25,6 +26,7 @@ logger = get_logger(__name__)
 
 class LocalCompute(
     ComputeWithCreateInstanceSupport,
+    ComputeWithPrivilegedSupport,
     ComputeWithVolumeSupport,
     Compute,
 ):

dstack/_internal/core/backends/nebius/compute.py

@@ -16,6 +16,7 @@ from dstack._internal.core.backends.base.compute import (
     ComputeWithCreateInstanceSupport,
     ComputeWithMultinodeSupport,
     ComputeWithPlacementGroupSupport,
+    ComputeWithPrivilegedSupport,
     generate_unique_instance_name,
     get_user_data,
 )
@@ -79,6 +80,7 @@ SUPPORTED_PLATFORMS = [
 class NebiusCompute(
     ComputeWithAllOffersCached,
     ComputeWithCreateInstanceSupport,
+    ComputeWithPrivilegedSupport,
     ComputeWithMultinodeSupport,
     ComputeWithPlacementGroupSupport,
     Compute,

dstack/_internal/core/backends/oci/compute.py

@@ -9,6 +9,7 @@ from dstack._internal.core.backends.base.compute import (
     ComputeWithAllOffersCached,
     ComputeWithCreateInstanceSupport,
     ComputeWithMultinodeSupport,
+    ComputeWithPrivilegedSupport,
     generate_unique_instance_name,
     get_user_data,
 )
@@ -50,6 +51,7 @@ CONFIGURABLE_DISK_SIZE = Range[Memory](min=Memory.parse("50GB"), max=Memory.pars
 class OCICompute(
     ComputeWithAllOffersCached,
     ComputeWithCreateInstanceSupport,
+    ComputeWithPrivilegedSupport,
     ComputeWithMultinodeSupport,
     Compute,
 ):

dstack/_internal/core/backends/template/compute.py.jinja

@@ -8,6 +8,7 @@ from dstack._internal.core.backends.base.compute import (
     ComputeWithMultinodeSupport,
     ComputeWithPlacementGroupSupport,
     ComputeWithPrivateGatewaySupport,
+    ComputeWithPrivilegedSupport,
     ComputeWithReservationSupport,
     ComputeWithVolumeSupport,
 )
@@ -31,6 +32,7 @@ class {{ backend_name }}Compute(
     # TODO: Choose ComputeWith* classes to extend and implement
     # ComputeWithAllOffersCached,
     # ComputeWithCreateInstanceSupport,
+    # ComputeWithPrivilegedSupport,
     # ComputeWithMultinodeSupport,
     # ComputeWithReservationSupport,
     # ComputeWithPlacementGroupSupport,

dstack/_internal/core/backends/tensordock/compute.py

@@ -6,6 +6,7 @@ import requests
 from dstack._internal.core.backends.base.backend import Compute
 from dstack._internal.core.backends.base.compute import (
     ComputeWithCreateInstanceSupport,
+    ComputeWithPrivilegedSupport,
     generate_unique_instance_name,
     get_shim_commands,
 )
@@ -32,6 +33,7 @@ MAX_INSTANCE_NAME_LEN = 60
 
 class TensorDockCompute(
     ComputeWithCreateInstanceSupport,
+    ComputeWithPrivilegedSupport,
     Compute,
 ):
     def __init__(self, config: TensorDockConfig):

dstack/_internal/core/backends/vultr/compute.py

@@ -9,6 +9,7 @@ from dstack._internal.core.backends.base.compute import (
     ComputeWithAllOffersCached,
     ComputeWithCreateInstanceSupport,
     ComputeWithMultinodeSupport,
+    ComputeWithPrivilegedSupport,
     generate_unique_instance_name,
     get_user_data,
 )
@@ -35,6 +36,7 @@ MAX_INSTANCE_NAME_LEN = 64
 class VultrCompute(
     ComputeWithAllOffersCached,
     ComputeWithCreateInstanceSupport,
+    ComputeWithPrivilegedSupport,
     ComputeWithMultinodeSupport,
     Compute,
 ):

dstack/_internal/server/background/tasks/common.py

@@ -19,4 +19,6 @@ def get_provisioning_timeout(backend_type: BackendType, instance_type_name: str)
         return timedelta(minutes=20)
     if backend_type == BackendType.VULTR and instance_type_name.startswith("vbm"):
         return timedelta(minutes=55)
+    if backend_type == BackendType.GCP and instance_type_name == "a4-highgpu-8g":
+        return timedelta(minutes=16)
     return timedelta(minutes=10)

dstack/_internal/server/background/tasks/process_instances.py

@@ -307,7 +307,7 @@ async def _add_remote(instance: InstanceModel) -> None:
             )
             deploy_timeout = 20 * 60  # 20 minutes
             result = await asyncio.wait_for(future, timeout=deploy_timeout)
-            health, host_info, cpu_arch = result
+            health, host_info, arch = result
         except (asyncio.TimeoutError, TimeoutError) as e:
             raise ProvisioningError(f"Deploy timeout: {e}") from e
         except Exception as e:
@@ -327,7 +327,7 @@ async def _add_remote(instance: InstanceModel) -> None:
         instance.status = InstanceStatus.PENDING
         return
 
-    instance_type = host_info_to_instance_type(host_info, cpu_arch)
+    instance_type = host_info_to_instance_type(host_info, arch)
     instance_network = None
     internal_ip = None
     try:

dstack/_internal/server/services/offers.py

@@ -7,6 +7,7 @@ from dstack._internal.core.backends.base.compute import ComputeWithPlacementGrou
 from dstack._internal.core.backends.features import (
     BACKENDS_WITH_CREATE_INSTANCE_SUPPORT,
     BACKENDS_WITH_MULTINODE_SUPPORT,
+    BACKENDS_WITH_PRIVILEGED_SUPPORT,
     BACKENDS_WITH_RESERVATION_SUPPORT,
 )
 from dstack._internal.core.models.backends.base import BackendType
@@ -67,7 +68,12 @@ async def get_offers_by_requirements(
             backend_types = BACKENDS_WITH_MULTINODE_SUPPORT
         backend_types = [b for b in backend_types if b in BACKENDS_WITH_MULTINODE_SUPPORT]
 
-    if privileged or instance_mounts:
+    if privileged:
+        if backend_types is None:
+            backend_types = BACKENDS_WITH_PRIVILEGED_SUPPORT
+        backend_types = [b for b in backend_types if b in BACKENDS_WITH_PRIVILEGED_SUPPORT]
+
+    if instance_mounts:
         if backend_types is None:
             backend_types = BACKENDS_WITH_CREATE_INSTANCE_SUPPORT
         backend_types = [b for b in backend_types if b in BACKENDS_WITH_CREATE_INSTANCE_SUPPORT]

dstack/_internal/server/testing/common.py

@@ -16,6 +16,7 @@ from dstack._internal.core.backends.base.compute import (
     ComputeWithMultinodeSupport,
     ComputeWithPlacementGroupSupport,
     ComputeWithPrivateGatewaySupport,
+    ComputeWithPrivilegedSupport,
     ComputeWithReservationSupport,
     ComputeWithVolumeSupport,
 )
@@ -1131,6 +1132,7 @@ class AsyncContextManager:
 class ComputeMockSpec(
     Compute,
     ComputeWithCreateInstanceSupport,
+    ComputeWithPrivilegedSupport,
     ComputeWithMultinodeSupport,
     ComputeWithReservationSupport,
     ComputeWithPlacementGroupSupport,

dstack/_internal/server/utils/provisioning.py

@@ -6,7 +6,7 @@ from textwrap import dedent
 from typing import Any, Dict, Generator, List, Optional
 
 import paramiko
-from gpuhunt import AcceleratorVendor, CPUArchitecture, correct_gpu_memory_gib
+from gpuhunt import AcceleratorVendor, correct_gpu_memory_gib
 
 from dstack._internal.core.backends.base.compute import GoArchType, normalize_arch
 from dstack._internal.core.consts import DSTACK_SHIM_HTTP_PORT
@@ -248,14 +248,7 @@ def _get_shim_healthcheck(client: paramiko.SSHClient) -> Optional[str]:
     return out
 
 
-def host_info_to_instance_type(host_info: Dict[str, Any], cpu_arch: GoArchType) -> InstanceType:
-    _cpu_arch: CPUArchitecture
-    if cpu_arch == "amd64":
-        _cpu_arch = CPUArchitecture.X86
-    elif cpu_arch == "arm64":
-        _cpu_arch = CPUArchitecture.ARM
-    else:
-        raise ValueError(f"Unexpected cpu_arch: {cpu_arch}")
+def host_info_to_instance_type(host_info: Dict[str, Any], arch: GoArchType) -> InstanceType:
     gpu_count = host_info.get("gpu_count", 0)
     if gpu_count > 0:
         gpu_vendor = AcceleratorVendor.cast(host_info.get("gpu_vendor", "nvidia"))
@@ -280,7 +273,7 @@ def host_info_to_instance_type(host_info: Dict[str, Any], cpu_arch: GoArchType)
     instance_type = InstanceType(
         name="instance",
         resources=Resources(
-            cpu_arch=_cpu_arch,
+            cpu_arch=arch.to_cpu_architecture(),
             cpus=host_info["cpus"],
             memory_mib=host_info["memory"] / 1024 / 1024,
             spot=False,

dstack/version.py

@@ -1,4 +1,4 @@
-__version__ = "0.19.30"
+__version__ = "0.19.31"
 __is_release__ = True
 base_image = "0.11rc2"
 base_image_ubuntu_version = "22.04"

{dstack-0.19.30.dist-info → dstack-0.19.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dstack
-Version: 0.19.30
+Version: 0.19.31
 Summary: dstack is an open-source orchestration engine for running AI workloads on any cloud or on-premises.
 Project-URL: Homepage, https://dstack.ai
 Project-URL: Source, https://github.com/dstackai/dstack
@@ -331,9 +331,11 @@ Description-Content-Type: text/markdown
 
 </div>
 
-`dstack` provides a unified control plane for running development, training, and inference on GPUs — across cloud VMs, Kubernetes, or on-prem clusters. It helps your team avoid vendor lock-in and reduce GPU costs.
+`dstack` is a unified control plane for GPU provisioning and orchestration that works with any GPU cloud, Kubernetes, or on-prem clusters. 
 
-#### Accelerators
+It streamlines development, training, and inference, and is compatible with any hardware, open-source tools, and frameworks.
+
+#### Hardware
 
 `dstack` supports `NVIDIA`, `AMD`, `Google TPU`, `Intel Gaudi`, and `Tenstorrent` accelerators out of the box.
 
@@ -358,15 +360,15 @@ Description-Content-Type: text/markdown
 
 #### Set up the server
 
-##### (Optional) Configure backends
+##### Configure backends
+
+To orchestrate compute across cloud providers or existing Kubernetes clusters, you need to configure backends.
 
-To use `dstack` with cloud providers, configure backends
-via the `~/.dstack/server/config.yml` file.
+Backends can be set up in `~/.dstack/server/config.yml` or through the [project settings page](../concepts/projects.md#backends) in the UI.
 
-For more details on how to configure backends, check [Backends](https://dstack.ai/docs/concepts/backends).
+For more details, see [Backends](../concepts/backends.md).
 
-> For using `dstack` with on-prem servers, create [SSH fleets](https://dstack.ai/docs/concepts/fleets#ssh) 
-> once the server is up.
+> When using `dstack` with on-prem servers, backend configuration isn’t required. Simply create [SSH fleets](../concepts/fleets.md#ssh) once the server is up.
 
 ##### Start the server