dstack 0.19.25rc1__py3-none-any.whl → 0.19.27__py3-none-any.whl

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

@@ -0,0 +1,173 @@
+from typing import List, Optional
+
+import gpuhunt
+from gpuhunt.providers.digitalocean import DigitalOceanProvider
+
+from dstack._internal.core.backends.base.backend import Compute
+from dstack._internal.core.backends.base.compute import (
+    ComputeWithCreateInstanceSupport,
+    generate_unique_instance_name,
+    get_user_data,
+)
+from dstack._internal.core.backends.base.offers import get_catalog_offers
+from dstack._internal.core.backends.digitalocean_base.api_client import DigitalOceanAPIClient
+from dstack._internal.core.backends.digitalocean_base.models import BaseDigitalOceanConfig
+from dstack._internal.core.errors import BackendError
+from dstack._internal.core.models.backends.base import BackendType
+from dstack._internal.core.models.instances import (
+    InstanceAvailability,
+    InstanceConfiguration,
+    InstanceOfferWithAvailability,
+)
+from dstack._internal.core.models.placement import PlacementGroup
+from dstack._internal.core.models.runs import JobProvisioningData, Requirements
+from dstack._internal.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+MAX_INSTANCE_NAME_LEN = 60
+DOCKER_INSTALL_COMMANDS = [
+    "export DEBIAN_FRONTEND=noninteractive",
+    "mkdir -p /etc/apt/keyrings",
+    "curl --max-time 60 -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg",
+    'echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null',
+    "apt-get update",
+    "apt-get --assume-yes install docker-ce docker-ce-cli containerd.io docker-compose-plugin",
+]
+
+
+class BaseDigitalOceanCompute(
+    ComputeWithCreateInstanceSupport,
+    Compute,
+):
+    def __init__(self, config: BaseDigitalOceanConfig, api_url: str, type: BackendType):
+        super().__init__()
+        self.config = config
+        self.api_client = DigitalOceanAPIClient(config.creds.api_key, api_url)
+        self.catalog = gpuhunt.Catalog(balance_resources=False, auto_reload=False)
+        self.BACKEND_TYPE = type
+        self.catalog.add_provider(
+            DigitalOceanProvider(api_key=config.creds.api_key, api_url=api_url)
+        )
+
+    def get_offers(
+        self, requirements: Optional[Requirements] = None
+    ) -> List[InstanceOfferWithAvailability]:
+        offers = get_catalog_offers(
+            backend=self.BACKEND_TYPE,
+            locations=self.config.regions,
+            requirements=requirements,
+            catalog=self.catalog,
+        )
+        return [
+            InstanceOfferWithAvailability(
+                **offer.dict(),
+                availability=InstanceAvailability.AVAILABLE,
+            )
+            for offer in offers
+        ]
+
+    def create_instance(
+        self,
+        instance_offer: InstanceOfferWithAvailability,
+        instance_config: InstanceConfiguration,
+        placement_group: Optional[PlacementGroup],
+    ) -> JobProvisioningData:
+        instance_name = generate_unique_instance_name(
+            instance_config, max_length=MAX_INSTANCE_NAME_LEN
+        )
+
+        project_ssh_key = instance_config.ssh_keys[0]
+        ssh_key_id = self.api_client.get_or_create_ssh_key(
+            name=f"dstack-{instance_config.project_name}",
+            public_key=project_ssh_key.public,
+        )
+        size_slug = instance_offer.instance.name
+
+        if not instance_offer.instance.resources.gpus:
+            backend_specific_commands = DOCKER_INSTALL_COMMANDS
+        else:
+            backend_specific_commands = None
+
+        project_id = None
+        if self.config.project_name:
+            project_id = self.api_client.get_project_id(self.config.project_name)
+            if project_id is None:
+                raise BackendError(f"Project {self.config.project_name} does not exist")
+        droplet_config = {
+            "name": instance_name,
+            "region": instance_offer.region,
+            "size": size_slug,
+            "image": self._get_image_for_instance(instance_offer),
+            "ssh_keys": [ssh_key_id],
+            "backups": False,
+            "ipv6": False,
+            "monitoring": False,
+            "tags": [],
+            "user_data": get_user_data(
+                authorized_keys=instance_config.get_public_keys(),
+                backend_specific_commands=backend_specific_commands,
+            ),
+            **({"project_id": project_id} if project_id is not None else {}),
+        }
+
+        droplet = self.api_client.create_droplet(droplet_config)
+
+        return JobProvisioningData(
+            backend=instance_offer.backend,
+            instance_type=instance_offer.instance,
+            instance_id=str(droplet["id"]),
+            hostname=None,
+            internal_ip=None,
+            region=instance_offer.region,
+            price=instance_offer.price,
+            username="root",
+            ssh_port=22,
+            dockerized=True,
+            ssh_proxy=None,
+            backend_data=None,
+        )
+
+    def update_provisioning_data(
+        self,
+        provisioning_data: JobProvisioningData,
+        project_ssh_public_key: str,
+        project_ssh_private_key: str,
+    ):
+        droplet = self.api_client.get_droplet(provisioning_data.instance_id)
+        if droplet["status"] == "active":
+            for network in droplet["networks"]["v4"]:
+                if network["type"] == "public":
+                    provisioning_data.hostname = network["ip_address"]
+                    break
+
+    def terminate_instance(
+        self, instance_id: str, region: str, backend_data: Optional[str] = None
+    ):
+        self.api_client.delete_droplet(instance_id)
+
+    def _get_image_for_instance(self, instance_offer: InstanceOfferWithAvailability) -> str:
+        if not instance_offer.instance.resources.gpus:
+            # No GPUs, use CPU image
+            return "ubuntu-24-04-x64"
+
+        gpu_count = len(instance_offer.instance.resources.gpus)
+        gpu_vendor = instance_offer.instance.resources.gpus[0].vendor
+
+        if gpu_vendor == gpuhunt.AcceleratorVendor.AMD:
+            # AMD GPU
+            return "digitaloceanai-rocmjupyter"
+        else:
+            # NVIDIA GPUs - DO only supports 1 and 8 GPU configurations.
+            # DO says for single GPU plans using GPUs other than H100s use "gpu-h100x1-base". DO does not provide guidance for x8 GPUs so assuming the same applies.
+            # See (https://docs.digitalocean.com/products/droplets/getting-started/recommended-gpu-setup/#aiml-ready-image)
+            if gpu_count == 8:
+                return "gpu-h100x8-base"
+            elif gpu_count == 1:
+                return "gpu-h100x1-base"
+            else:
+                # For Unsupported GPU count - use single GPU image and log warning
+                logger.warning(
+                    f"Unsupported NVIDIA GPU count: {gpu_count}, using single GPU image"
+                )
+                return "gpu-h100x1-base"

dstack/_internal/core/backends/digitalocean_base/configurator.py

@@ -0,0 +1,57 @@
+import json
+from typing import Optional
+
+from dstack._internal.core.backends.base.configurator import (
+    BackendRecord,
+    Configurator,
+)
+from dstack._internal.core.backends.digitalocean_base.backend import BaseDigitalOceanBackend
+from dstack._internal.core.backends.digitalocean_base.models import (
+    AnyBaseDigitalOceanCreds,
+    BaseDigitalOceanBackendConfig,
+    BaseDigitalOceanBackendConfigWithCreds,
+    BaseDigitalOceanConfig,
+    BaseDigitalOceanCreds,
+    BaseDigitalOceanStoredConfig,
+)
+
+
+class BaseDigitalOceanConfigurator(Configurator):
+    def validate_config(
+        self, config: BaseDigitalOceanBackendConfigWithCreds, default_creds_enabled: bool
+    ):
+        self._validate_creds(config.creds, config.project_name)
+
+    def create_backend(
+        self, project_name: str, config: BaseDigitalOceanBackendConfigWithCreds
+    ) -> BackendRecord:
+        return BackendRecord(
+            config=BaseDigitalOceanStoredConfig(
+                **BaseDigitalOceanBackendConfig.__response__.parse_obj(config).dict()
+            ).json(),
+            auth=BaseDigitalOceanCreds.parse_obj(config.creds).json(),
+        )
+
+    def get_backend_config_with_creds(
+        self, record: BackendRecord
+    ) -> BaseDigitalOceanBackendConfigWithCreds:
+        config = self._get_config(record)
+        return BaseDigitalOceanBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(
+        self, record: BackendRecord
+    ) -> BaseDigitalOceanBackendConfig:
+        config = self._get_config(record)
+        return BaseDigitalOceanBackendConfig.__response__.parse_obj(config)
+
+    def get_backend(self, record: BackendRecord) -> BaseDigitalOceanBackend:
+        raise NotImplementedError("Subclasses must implement get_backend")
+
+    def _get_config(self, record: BackendRecord) -> BaseDigitalOceanConfig:
+        return BaseDigitalOceanConfig.__response__(
+            **json.loads(record.config),
+            creds=BaseDigitalOceanCreds.parse_raw(record.auth),
+        )
+
+    def _validate_creds(self, creds: AnyBaseDigitalOceanCreds, project_name: Optional[str] = None):
+        pass

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

@@ -0,0 +1,43 @@
+from typing import Annotated, List, Literal, Optional, Union
+
+from pydantic import Field
+
+from dstack._internal.core.models.common import CoreModel
+
+
+class BaseDigitalOceanAPIKeyCreds(CoreModel):
+    type: Annotated[Literal["api_key"], Field(description="The type of credentials")] = "api_key"
+    api_key: Annotated[str, Field(description="The API key")]
+
+
+AnyBaseDigitalOceanCreds = BaseDigitalOceanAPIKeyCreds
+BaseDigitalOceanCreds = AnyBaseDigitalOceanCreds
+
+
+class BaseDigitalOceanBackendConfig(CoreModel):
+    type: Annotated[
+        Literal["amddevcloud", "digitalocean"],
+        Field(description="The type of backend"),
+    ]
+    project_name: Annotated[Optional[str], Field(description="The name of the project")] = None
+    regions: Annotated[
+        Optional[List[str]],
+        Field(description="The list of regions. Omit to use all regions"),
+    ] = None
+
+
+class BaseDigitalOceanBackendConfigWithCreds(BaseDigitalOceanBackendConfig):
+    creds: Annotated[AnyBaseDigitalOceanCreds, Field(description="The credentials")]
+
+
+AnyBaseDigitalOceanBackendConfig = Union[
+    BaseDigitalOceanBackendConfig, BaseDigitalOceanBackendConfigWithCreds
+]
+
+
+class BaseDigitalOceanStoredConfig(BaseDigitalOceanBackendConfig):
+    pass
+
+
+class BaseDigitalOceanConfig(BaseDigitalOceanStoredConfig):
+    creds: AnyBaseDigitalOceanCreds

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

@@ -2,6 +2,7 @@ import concurrent.futures
 import json
 import threading
 from collections import defaultdict
+from dataclasses import dataclass
 from typing import Callable, Dict, List, Literal, Optional, Tuple
 
 import google.api_core.exceptions
@@ -285,16 +286,18 @@ class GCPCompute(
                 )
             raise NoCapacityError()
 
+        image = _get_image(
+            instance_type_name=instance_offer.instance.name,
+            cuda=len(instance_offer.instance.resources.gpus) > 0,
+        )
+
         for zone in zones:
             request = compute_v1.InsertInstanceRequest()
             request.zone = zone
             request.project = self.config.project_id
             request.instance_resource = gcp_resources.create_instance_struct(
                 disk_size=disk_size,
-                image_id=_get_image_id(
-                    instance_type_name=instance_offer.instance.name,
-                    cuda=len(instance_offer.instance.resources.gpus) > 0,
-                ),
+                image_id=image.id,
                 machine_type=instance_offer.instance.name,
                 accelerators=gcp_resources.get_accelerators(
                     project_id=self.config.project_id,
@@ -305,6 +308,7 @@ class GCPCompute(
                 user_data=_get_user_data(
                     authorized_keys=authorized_keys,
                     instance_type_name=instance_offer.instance.name,
+                    is_ufw_installed=image.is_ufw_installed,
                 ),
                 authorized_keys=authorized_keys,
                 labels=labels,
@@ -889,24 +893,41 @@ def _get_vpc_subnet(
     )
 
 
-def _get_image_id(instance_type_name: str, cuda: bool) -> str:
+@dataclass
+class GCPImage:
+    id: str
+    is_ufw_installed: bool
+
+
+def _get_image(instance_type_name: str, cuda: bool) -> GCPImage:
     if instance_type_name == "a3-megagpu-8g":
         image_name = "dstack-a3mega-5"
+        is_ufw_installed = False
     elif instance_type_name in ["a3-edgegpu-8g", "a3-highgpu-8g"]:
-        return "projects/cos-cloud/global/images/cos-105-17412-535-78"
+        return GCPImage(
+            id="projects/cos-cloud/global/images/cos-105-17412-535-78",
+            is_ufw_installed=False,
+        )
     elif cuda:
         image_name = f"dstack-cuda-{version.base_image}"
+        is_ufw_installed = True
     else:
         image_name = f"dstack-{version.base_image}"
+        is_ufw_installed = True
     image_name = image_name.replace(".", "-")
-    return f"projects/dstack/global/images/{image_name}"
+    return GCPImage(
+        id=f"projects/dstack/global/images/{image_name}",
+        is_ufw_installed=is_ufw_installed,
+    )
 
 
 def _get_gateway_image_id() -> str:
     return "projects/ubuntu-os-cloud/global/images/ubuntu-2204-jammy-v20230714"
 
 
-def _get_user_data(authorized_keys: List[str], instance_type_name: str) -> str:
+def _get_user_data(
+    authorized_keys: List[str], instance_type_name: str, is_ufw_installed: bool
+) -> str:
     base_path = None
     bin_path = None
     backend_shim_env = None
@@ -929,6 +950,9 @@ def _get_user_data(authorized_keys: List[str], instance_type_name: str) -> str:
         base_path=base_path,
         bin_path=bin_path,
         backend_shim_env=backend_shim_env,
+        # Instance-level firewall is optional on GCP. The main protection comes from GCP firewalls.
+        # So only set up instance-level firewall as an additional measure if ufw is available.
+        skip_firewall_setup=not is_ufw_installed,
     )
 
 

dstack/_internal/core/backends/gcp/configurator.py

@@ -11,7 +11,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.gcp import auth, resources
 from dstack._internal.core.backends.gcp.backend import GCPBackend
 from dstack._internal.core.backends.gcp.models import (
-    AnyGCPBackendConfig,
     GCPBackendConfig,
     GCPBackendConfigWithCreds,
     GCPConfig,
@@ -109,7 +108,12 @@ DEFAULT_REGIONS = REGIONS
 MAIN_REGION = "us-east1"
 
 
-class GCPConfigurator(Configurator):
+class GCPConfigurator(
+    Configurator[
+        GCPBackendConfig,
+        GCPBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.GCP
     BACKEND_CLASS = GCPBackend
 
@@ -147,12 +151,12 @@ class GCPConfigurator(Configurator):
             auth=GCPCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyGCPBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> GCPBackendConfigWithCreds:
+        config = self._get_config(record)
+        return GCPBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> GCPBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return GCPBackendConfigWithCreds.__response__.parse_obj(config)
         return GCPBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> GCPBackend:

dstack/_internal/core/backends/hotaisle/api_client.py

@@ -16,46 +16,38 @@ class HotAisleAPIClient:
         self.team_handle = team_handle
 
     def validate_api_key(self) -> bool:
+        url = f"{API_URL}/user/"
         try:
-            self._validate_user_and_team()
-            return True
+            response = self._make_request("GET", url)
+            response.raise_for_status()
         except requests.HTTPError as e:
-            if e.response.status_code == 401:
-                raise_invalid_credentials_error(
-                    fields=[["creds", "api_key"]], details="Invalid API key"
-                )
-            elif e.response.status_code == 403:
-                raise_invalid_credentials_error(
-                    fields=[["creds", "api_key"]],
-                    details="Authenticated user does note have required permissions",
-                )
-            raise e
-        except ValueError as e:
-            error_message = str(e)
-            if "No Hot Aisle teams found" in error_message:
-                raise_invalid_credentials_error(
-                    fields=[["creds", "api_key"]],
-                    details="Valid API key but no teams found for this user",
-                )
-            elif "not found" in error_message:
-                raise_invalid_credentials_error(
-                    fields=[["team_handle"]], details=f"Team handle '{self.team_handle}' not found"
-                )
-            raise e
-
-    def _validate_user_and_team(self) -> None:
-        url = f"{API_URL}/user/"
-        response = self._make_request("GET", url)
-        response.raise_for_status()
-        user_data = response.json()
+            if e.response is not None:
+                if e.response.status_code == 401:
+                    raise_invalid_credentials_error(
+                        fields=[["creds", "api_key"]], details="Invalid API key"
+                    )
+                if e.response.status_code == 403:
+                    raise_invalid_credentials_error(
+                        fields=[["creds", "api_key"]],
+                        details="Authenticated user does not have required permissions",
+                    )
+            raise
 
-        teams = user_data.get("teams", [])
+        user_data = response.json()
+        teams = user_data["teams"]
         if not teams:
-            raise ValueError("No Hot Aisle teams found for this user")
+            raise_invalid_credentials_error(
+                fields=[["creds", "api_key"]],
+                details="Valid API key but no teams found for this user",
+            )
 
         available_teams = [team["handle"] for team in teams]
         if self.team_handle not in available_teams:
-            raise ValueError(f"Hot Aisle team '{self.team_handle}' not found.")
+            raise_invalid_credentials_error(
+                fields=[["team_handle"]],
+                details=f"Team handle '{self.team_handle}' not found",
+            )
+        return True
 
     def upload_ssh_key(self, public_key: str) -> bool:
         url = f"{API_URL}/user/ssh_keys/"

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

@@ -28,8 +28,6 @@ from dstack._internal.utils.logging import get_logger
 
 logger = get_logger(__name__)
 
-MAX_INSTANCE_NAME_LEN = 60
-
 
 INSTANCE_TYPE_SPECS = {
     "1x MI300X 8x Xeon Platinum 8462Y+": {
@@ -130,9 +128,7 @@ class HotAisleCompute(
             ssh_port=22,
             dockerized=True,
             ssh_proxy=None,
-            backend_data=HotAisleInstanceBackendData(
-                ip_address=vm_data["ip_address"], vm_id=vm_data["name"]
-            ).json(),
+            backend_data=HotAisleInstanceBackendData(ip_address=vm_data["ip_address"]).json(),
         )
 
     def update_provisioning_data(
@@ -217,7 +213,6 @@ def _run_ssh_command(hostname: str, ssh_private_key: str, command: str):
 
 class HotAisleInstanceBackendData(CoreModel):
     ip_address: str
-    vm_id: Optional[str] = None
 
     @classmethod
     def load(cls, raw: Optional[str]) -> "HotAisleInstanceBackendData":

dstack/_internal/core/backends/hotaisle/configurator.py

@@ -7,7 +7,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.hotaisle.api_client import HotAisleAPIClient
 from dstack._internal.core.backends.hotaisle.backend import HotAisleBackend
 from dstack._internal.core.backends.hotaisle.models import (
-    AnyHotAisleBackendConfig,
     AnyHotAisleCreds,
     HotAisleBackendConfig,
     HotAisleBackendConfigWithCreds,
@@ -20,7 +19,12 @@ from dstack._internal.core.models.backends.base import (
 )
 
 
-class HotAisleConfigurator(Configurator):
+class HotAisleConfigurator(
+    Configurator[
+        HotAisleBackendConfig,
+        HotAisleBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.HOTAISLE
     BACKEND_CLASS = HotAisleBackend
 
@@ -37,12 +41,14 @@ class HotAisleConfigurator(Configurator):
             auth=HotAisleCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyHotAisleBackendConfig:
+    def get_backend_config_with_creds(
+        self, record: BackendRecord
+    ) -> HotAisleBackendConfigWithCreds:
+        config = self._get_config(record)
+        return HotAisleBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> HotAisleBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return HotAisleBackendConfigWithCreds.__response__.parse_obj(config)
         return HotAisleBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> HotAisleBackend:

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

@@ -6,7 +6,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.kubernetes import utils as kubernetes_utils
 from dstack._internal.core.backends.kubernetes.backend import KubernetesBackend
 from dstack._internal.core.backends.kubernetes.models import (
-    AnyKubernetesBackendConfig,
     KubernetesBackendConfig,
     KubernetesBackendConfigWithCreds,
     KubernetesConfig,
@@ -18,7 +17,12 @@ from dstack._internal.utils.logging import get_logger
 logger = get_logger(__name__)
 
 
-class KubernetesConfigurator(Configurator):
+class KubernetesConfigurator(
+    Configurator[
+        KubernetesBackendConfig,
+        KubernetesBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.KUBERNETES
     BACKEND_CLASS = KubernetesBackend
 
@@ -40,12 +44,14 @@ class KubernetesConfigurator(Configurator):
             auth="",
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyKubernetesBackendConfig:
+    def get_backend_config_with_creds(
+        self, record: BackendRecord
+    ) -> KubernetesBackendConfigWithCreds:
+        config = self._get_config(record)
+        return KubernetesBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> KubernetesBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return KubernetesBackendConfigWithCreds.__response__.parse_obj(config)
         return KubernetesBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> KubernetesBackend:

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

@@ -8,7 +8,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.lambdalabs import api_client
 from dstack._internal.core.backends.lambdalabs.backend import LambdaBackend
 from dstack._internal.core.backends.lambdalabs.models import (
-    AnyLambdaBackendConfig,
     LambdaBackendConfig,
     LambdaBackendConfigWithCreds,
     LambdaConfig,
@@ -20,7 +19,12 @@ from dstack._internal.core.models.backends.base import (
 )
 
 
-class LambdaConfigurator(Configurator):
+class LambdaConfigurator(
+    Configurator[
+        LambdaBackendConfig,
+        LambdaBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.LAMBDA
     BACKEND_CLASS = LambdaBackend
 
@@ -37,12 +41,12 @@ class LambdaConfigurator(Configurator):
             auth=LambdaCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyLambdaBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> LambdaBackendConfigWithCreds:
+        config = self._get_config(record)
+        return LambdaBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> LambdaBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return LambdaBackendConfigWithCreds.__response__.parse_obj(config)
         return LambdaBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> LambdaBackend:

dstack/_internal/core/backends/models.py

@@ -20,6 +20,10 @@ from dstack._internal.core.backends.datacrunch.models import (
     DataCrunchBackendConfig,
     DataCrunchBackendConfigWithCreds,
 )
+from dstack._internal.core.backends.digitalocean_base.models import (
+    BaseDigitalOceanBackendConfig,
+    BaseDigitalOceanBackendConfigWithCreds,
+)
 from dstack._internal.core.backends.dstack.models import (
     DstackBackendConfig,
     DstackBaseBackendConfig,
@@ -77,6 +81,7 @@ AnyBackendConfigWithoutCreds = Union[
     CloudRiftBackendConfig,
     CudoBackendConfig,
     DataCrunchBackendConfig,
+    BaseDigitalOceanBackendConfig,
     GCPBackendConfig,
     HotAisleBackendConfig,
     KubernetesBackendConfig,
@@ -100,6 +105,7 @@ AnyBackendConfigWithCreds = Union[
     CloudRiftBackendConfigWithCreds,
     CudoBackendConfigWithCreds,
     DataCrunchBackendConfigWithCreds,
+    BaseDigitalOceanBackendConfigWithCreds,
     GCPBackendConfigWithCreds,
     HotAisleBackendConfigWithCreds,
     KubernetesBackendConfigWithCreds,
@@ -122,6 +128,7 @@ AnyBackendFileConfigWithCreds = Union[
     CloudRiftBackendConfigWithCreds,
     CudoBackendConfigWithCreds,
     DataCrunchBackendConfigWithCreds,
+    BaseDigitalOceanBackendConfigWithCreds,
     GCPBackendFileConfigWithCreds,
     HotAisleBackendFileConfigWithCreds,
     KubernetesBackendFileConfigWithCreds,