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

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

@@ -0,0 +1,5 @@
+from dstack._internal.core.backends.digitalocean_base.compute import BaseDigitalOceanCompute
+
+
+class AMDDevCloudCompute(BaseDigitalOceanCompute):
+    pass

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

@@ -0,0 +1,29 @@
+from typing import Optional
+
+from dstack._internal.core.backends.amddevcloud.backend import AMDDevCloudBackend
+from dstack._internal.core.backends.base.configurator import BackendRecord
+from dstack._internal.core.backends.digitalocean_base.api_client import DigitalOceanAPIClient
+from dstack._internal.core.backends.digitalocean_base.backend import BaseDigitalOceanBackend
+from dstack._internal.core.backends.digitalocean_base.configurator import (
+    BaseDigitalOceanConfigurator,
+)
+from dstack._internal.core.backends.digitalocean_base.models import AnyBaseDigitalOceanCreds
+from dstack._internal.core.models.backends.base import (
+    BackendType,
+)
+
+
+class AMDDevCloudConfigurator(BaseDigitalOceanConfigurator):
+    TYPE = BackendType.AMDDEVCLOUD
+    BACKEND_CLASS = AMDDevCloudBackend
+    API_URL = "https://api-amd.digitalocean.com"
+
+    def get_backend(self, record: BackendRecord) -> BaseDigitalOceanBackend:
+        config = self._get_config(record)
+        return AMDDevCloudBackend(config=config, api_url=self.API_URL)
+
+    def _validate_creds(self, creds: AnyBaseDigitalOceanCreds, project_name: Optional[str] = None):
+        api_client = DigitalOceanAPIClient(creds.api_key, self.API_URL)
+        api_client.validate_api_key()
+        if project_name:
+            api_client.validate_project_name(project_name)

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

@@ -292,7 +292,12 @@ class AWSCompute(
                         image_id=image_id,
                         instance_type=instance_offer.instance.name,
                         iam_instance_profile=self.config.iam_instance_profile,
-                        user_data=get_user_data(authorized_keys=instance_config.get_public_keys()),
+                        user_data=get_user_data(
+                            authorized_keys=instance_config.get_public_keys(),
+                            # Custom OS images may lack ufw, so don't attempt to set up the firewall.
+                            # Rely on security groups and the image's built-in firewall rules instead.
+                            skip_firewall_setup=self.config.os_images is not None,
+                        ),
                         tags=aws_resources.make_tags(tags),
                         security_group_id=security_group_id,
                         spot=instance_offer.instance.resources.spot,

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

@@ -7,7 +7,6 @@ from boto3.session import Session
 from dstack._internal.core.backends.aws import auth, compute, resources
 from dstack._internal.core.backends.aws.backend import AWSBackend
 from dstack._internal.core.backends.aws.models import (
-    AnyAWSBackendConfig,
     AWSAccessKeyCreds,
     AWSBackendConfig,
     AWSBackendConfigWithCreds,
@@ -52,7 +51,12 @@ DEFAULT_REGIONS = REGION_VALUES
 MAIN_REGION = "us-east-1"
 
 
-class AWSConfigurator(Configurator):
+class AWSConfigurator(
+    Configurator[
+        AWSBackendConfig,
+        AWSBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.AWS
     BACKEND_CLASS = AWSBackend
 
@@ -87,12 +91,12 @@ class AWSConfigurator(Configurator):
             auth=AWSCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyAWSBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> AWSBackendConfigWithCreds:
+        config = self._get_config(record)
+        return AWSBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> AWSBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return AWSBackendConfigWithCreds.__response__.parse_obj(config)
         return AWSBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> AWSBackend:

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

@@ -24,7 +24,6 @@ from dstack._internal.core.backends.azure import auth, compute, resources
 from dstack._internal.core.backends.azure import utils as azure_utils
 from dstack._internal.core.backends.azure.backend import AzureBackend
 from dstack._internal.core.backends.azure.models import (
-    AnyAzureBackendConfig,
     AzureBackendConfig,
     AzureBackendConfigWithCreds,
     AzureClientCreds,
@@ -71,7 +70,12 @@ DEFAULT_LOCATIONS = LOCATION_VALUES
 MAIN_LOCATION = "eastus"
 
 
-class AzureConfigurator(Configurator):
+class AzureConfigurator(
+    Configurator[
+        AzureBackendConfig,
+        AzureBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.AZURE
     BACKEND_CLASS = AzureBackend
 
@@ -130,12 +134,12 @@ class AzureConfigurator(Configurator):
             auth=AzureCreds.parse_obj(config.creds).__root__.json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyAzureBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> AzureBackendConfigWithCreds:
+        config = self._get_config(record)
+        return AzureBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> AzureBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return AzureBackendConfigWithCreds.__response__.parse_obj(config)
         return AzureBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> AzureBackend:

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

@@ -4,6 +4,7 @@ import re
 import string
 import threading
 from abc import ABC, abstractmethod
+from collections.abc import Iterable
 from functools import lru_cache
 from pathlib import Path
 from typing import Dict, List, Literal, Optional
@@ -19,7 +20,7 @@ from dstack._internal.core.consts import (
     DSTACK_RUNNER_SSH_PORT,
     DSTACK_SHIM_HTTP_PORT,
 )
-from dstack._internal.core.models.configurations import DEFAULT_REPO_DIR
+from dstack._internal.core.models.configurations import LEGACY_REPO_DIR
 from dstack._internal.core.models.gateways import (
     GatewayComputeConfiguration,
     GatewayProvisioningData,
@@ -45,6 +46,7 @@ logger = get_logger(__name__)
 
 DSTACK_SHIM_BINARY_NAME = "dstack-shim"
 DSTACK_RUNNER_BINARY_NAME = "dstack-runner"
+DEFAULT_PRIVATE_SUBNETS = ("10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16")
 
 GoArchType = Literal["amd64", "arm64"]
 
@@ -507,12 +509,16 @@ def get_user_data(
     base_path: Optional[PathLike] = None,
     bin_path: Optional[PathLike] = None,
     backend_shim_env: Optional[Dict[str, str]] = None,
+    skip_firewall_setup: bool = False,
+    firewall_allow_from_subnets: Iterable[str] = DEFAULT_PRIVATE_SUBNETS,
 ) -> str:
     shim_commands = get_shim_commands(
         authorized_keys=authorized_keys,
         base_path=base_path,
         bin_path=bin_path,
         backend_shim_env=backend_shim_env,
+        skip_firewall_setup=skip_firewall_setup,
+        firewall_allow_from_subnets=firewall_allow_from_subnets,
     )
     commands = (backend_specific_commands or []) + shim_commands
     return get_cloud_config(
@@ -554,8 +560,13 @@ def get_shim_commands(
     bin_path: Optional[PathLike] = None,
     backend_shim_env: Optional[Dict[str, str]] = None,
     arch: Optional[str] = None,
+    skip_firewall_setup: bool = False,
+    firewall_allow_from_subnets: Iterable[str] = DEFAULT_PRIVATE_SUBNETS,
 ) -> List[str]:
-    commands = get_setup_cloud_instance_commands()
+    commands = get_setup_cloud_instance_commands(
+        skip_firewall_setup=skip_firewall_setup,
+        firewall_allow_from_subnets=firewall_allow_from_subnets,
+    )
     commands += get_shim_pre_start_commands(
         base_path=base_path,
         bin_path=bin_path,
@@ -638,8 +649,11 @@ def get_dstack_shim_download_url(arch: Optional[str] = None) -> str:
     return url_template.format(version=version, arch=arch)
 
 
-def get_setup_cloud_instance_commands() -> list[str]:
-    return [
+def get_setup_cloud_instance_commands(
+    skip_firewall_setup: bool,
+    firewall_allow_from_subnets: Iterable[str],
+) -> list[str]:
+    commands = [
         # Workaround for https://github.com/NVIDIA/nvidia-container-toolkit/issues/48
         # Attempts to patch /etc/docker/daemon.json while keeping any custom settings it may have.
         (
@@ -653,6 +667,19 @@ def get_setup_cloud_instance_commands() -> list[str]:
             "'"
         ),
     ]
+    if not skip_firewall_setup:
+        commands += [
+            "ufw --force reset",  # Some OS images have default rules like `allow 80`. Delete them
+            "ufw default deny incoming",
+            "ufw default allow outgoing",
+            "ufw allow ssh",
+        ]
+        for subnet in firewall_allow_from_subnets:
+            commands.append(f"ufw allow from {subnet}")
+        commands += [
+            "ufw --force enable",
+        ]
+    return commands
 
 
 def get_shim_pre_start_commands(
@@ -773,7 +800,8 @@ def get_docker_commands(
             f" --ssh-port {DSTACK_RUNNER_SSH_PORT}"
             " --temp-dir /tmp/runner"
             " --home-dir /root"
-            f" --working-dir {DEFAULT_REPO_DIR}"
+            # TODO: Not used, left for compatibility with old runners. Remove eventually.
+            f" --working-dir {LEGACY_REPO_DIR}"
         ),
     ]
 

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

@@ -1,11 +1,11 @@
 from abc import ABC, abstractmethod
-from typing import Any, ClassVar, List, Optional
+from typing import Any, ClassVar, Generic, List, Optional, TypeVar
 from uuid import UUID
 
 from dstack._internal.core.backends.base.backend import Backend
 from dstack._internal.core.backends.models import (
-    AnyBackendConfig,
     AnyBackendConfigWithCreds,
+    AnyBackendConfigWithoutCreds,
 )
 from dstack._internal.core.errors import BackendInvalidCredentialsError
 from dstack._internal.core.models.backends.base import BackendType
@@ -15,6 +15,11 @@ from dstack._internal.core.models.common import CoreModel
 # We'll introduce our own base limit that can be customized per backend if required.
 TAGS_MAX_NUM = 25
 
+BackendConfigWithoutCredsT = TypeVar(
+    "BackendConfigWithoutCredsT", bound=AnyBackendConfigWithoutCreds
+)
+BackendConfigWithCredsT = TypeVar("BackendConfigWithCredsT", bound=AnyBackendConfigWithCreds)
+
 
 class BackendRecord(CoreModel):
     """
@@ -39,7 +44,7 @@ class StoredBackendRecord(BackendRecord):
     backend_id: UUID
 
 
-class Configurator(ABC):
+class Configurator(ABC, Generic[BackendConfigWithoutCredsT, BackendConfigWithCredsT]):
     """
     `Configurator` is responsible for configuring backends
     and initializing `Backend` instances from backend configs.
@@ -52,7 +57,7 @@ class Configurator(ABC):
     BACKEND_CLASS: ClassVar[type[Backend]]
 
     @abstractmethod
-    def validate_config(self, config: AnyBackendConfigWithCreds, default_creds_enabled: bool):
+    def validate_config(self, config: BackendConfigWithCredsT, default_creds_enabled: bool):
         """
         Validates backend config including backend creds and other parameters.
         Raises `ServerClientError` or its subclass if config is invalid.
@@ -61,9 +66,7 @@ class Configurator(ABC):
         pass
 
     @abstractmethod
-    def create_backend(
-        self, project_name: str, config: AnyBackendConfigWithCreds
-    ) -> BackendRecord:
+    def create_backend(self, project_name: str, config: BackendConfigWithCredsT) -> BackendRecord:
         """
         Sets up backend given backend config and returns
         text-encoded config and creds to be stored in the DB.
@@ -78,13 +81,22 @@ class Configurator(ABC):
         pass
 
     @abstractmethod
-    def get_backend_config(
-        self, record: StoredBackendRecord, include_creds: bool
-    ) -> AnyBackendConfig:
+    def get_backend_config_with_creds(
+        self, record: StoredBackendRecord
+    ) -> BackendConfigWithCredsT:
+        """
+        Constructs `BackendConfig` with credentials included.
+        Used internally and when project admins need to see backend's creds.
+        """
+        pass
+
+    @abstractmethod
+    def get_backend_config_without_creds(
+        self, record: StoredBackendRecord
+    ) -> BackendConfigWithoutCredsT:
         """
-        Constructs `BackendConfig` to be returned in API responses.
-        Project admins may need to see backend's creds. In this case `include_creds` will be `True`.
-        Otherwise, no sensitive information should be included.
+        Constructs `BackendConfig` without sensitive information.
+        Used for API responses where creds should not be exposed.
         """
         pass
 

dstack/_internal/core/backends/base/offers.py

@@ -34,6 +34,8 @@ def get_catalog_offers(
     provider = backend.value
     if backend == BackendType.LAMBDA:
         provider = "lambdalabs"
+    if backend == BackendType.AMDDEVCLOUD:
+        provider = "digitalocean"
     q = requirements_to_query_filter(requirements)
     q.provider = [provider]
     offers = []

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

@@ -8,7 +8,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.cloudrift.api_client import RiftClient
 from dstack._internal.core.backends.cloudrift.backend import CloudRiftBackend
 from dstack._internal.core.backends.cloudrift.models import (
-    AnyCloudRiftBackendConfig,
     AnyCloudRiftCreds,
     CloudRiftBackendConfig,
     CloudRiftBackendConfigWithCreds,
@@ -21,7 +20,12 @@ from dstack._internal.core.models.backends.base import (
 )
 
 
-class CloudRiftConfigurator(Configurator):
+class CloudRiftConfigurator(
+    Configurator[
+        CloudRiftBackendConfig,
+        CloudRiftBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.CLOUDRIFT
     BACKEND_CLASS = CloudRiftBackend
 
@@ -40,12 +44,14 @@ class CloudRiftConfigurator(Configurator):
             auth=CloudRiftCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyCloudRiftBackendConfig:
+    def get_backend_config_with_creds(
+        self, record: BackendRecord
+    ) -> CloudRiftBackendConfigWithCreds:
+        config = self._get_config(record)
+        return CloudRiftBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> CloudRiftBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return CloudRiftBackendConfigWithCreds.__response__.parse_obj(config)
         return CloudRiftBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> CloudRiftBackend:

dstack/_internal/core/backends/configurators.py

@@ -5,6 +5,12 @@ from dstack._internal.core.models.backends.base import BackendType
 
 _CONFIGURATOR_CLASSES: List[Type[Configurator]] = []
 
+try:
+    from dstack._internal.core.backends.amddevcloud.configurator import AMDDevCloudConfigurator
+
+    _CONFIGURATOR_CLASSES.append(AMDDevCloudConfigurator)
+except ImportError:
+    pass
 
 try:
     from dstack._internal.core.backends.aws.configurator import AWSConfigurator
@@ -47,6 +53,15 @@ try:
 except ImportError:
     pass
 
+try:
+    from dstack._internal.core.backends.digitalocean.configurator import (
+        DigitalOceanConfigurator,
+    )
+
+    _CONFIGURATOR_CLASSES.append(DigitalOceanConfigurator)
+except ImportError:
+    pass
+
 try:
     from dstack._internal.core.backends.gcp.configurator import GCPConfigurator
 

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

@@ -8,7 +8,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.cudo import api_client
 from dstack._internal.core.backends.cudo.backend import CudoBackend
 from dstack._internal.core.backends.cudo.models import (
-    AnyCudoBackendConfig,
     CudoBackendConfig,
     CudoBackendConfigWithCreds,
     CudoConfig,
@@ -18,7 +17,12 @@ from dstack._internal.core.backends.cudo.models import (
 from dstack._internal.core.models.backends.base import BackendType
 
 
-class CudoConfigurator(Configurator):
+class CudoConfigurator(
+    Configurator[
+        CudoBackendConfig,
+        CudoBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.CUDO
     BACKEND_CLASS = CudoBackend
 
@@ -35,12 +39,12 @@ class CudoConfigurator(Configurator):
             auth=CudoCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyCudoBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> CudoBackendConfigWithCreds:
+        config = self._get_config(record)
+        return CudoBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> CudoBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return CudoBackendConfigWithCreds.__response__.parse_obj(config)
         return CudoBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> CudoBackend:

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

@@ -161,7 +161,10 @@ class DataCrunchCompute(
         try:
             self.client.instances.action(id_list=[instance_id], action="delete")
         except APIException as e:
-            if e.message == "Invalid instance id":
+            if e.message in [
+                "Invalid instance id",
+                "Can't discontinue a discontinued instance",
+            ]:
                 logger.debug("Skipping instance %s termination. Instance not found.", instance_id)
                 return
             raise
@@ -243,6 +246,7 @@ def _deploy_instance(
             hostname=hostname,
             description=description,
             startup_script_id=startup_script_id,
+            pricing="FIXED_PRICE",
             is_spot=is_spot,
             location=location,
             os_volume={"name": "OS volume", "size": disk_size},

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

@@ -10,7 +10,6 @@ from dstack._internal.core.backends.base.configurator import (
 )
 from dstack._internal.core.backends.datacrunch.backend import DataCrunchBackend
 from dstack._internal.core.backends.datacrunch.models import (
-    AnyDataCrunchBackendConfig,
     DataCrunchBackendConfig,
     DataCrunchBackendConfigWithCreds,
     DataCrunchConfig,
@@ -22,7 +21,12 @@ from dstack._internal.core.models.backends.base import (
 )
 
 
-class DataCrunchConfigurator(Configurator):
+class DataCrunchConfigurator(
+    Configurator[
+        DataCrunchBackendConfig,
+        DataCrunchBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.DATACRUNCH
     BACKEND_CLASS = DataCrunchBackend
 
@@ -41,12 +45,14 @@ class DataCrunchConfigurator(Configurator):
             auth=DataCrunchCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyDataCrunchBackendConfig:
+    def get_backend_config_with_creds(
+        self, record: BackendRecord
+    ) -> DataCrunchBackendConfigWithCreds:
+        config = self._get_config(record)
+        return DataCrunchBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> DataCrunchBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return DataCrunchBackendConfigWithCreds.__response__.parse_obj(config)
         return DataCrunchBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> DataCrunchBackend:

dstack/_internal/core/backends/digitalocean/__init__.py

@@ -0,0 +1 @@
+# DigitalOcean backend for dstack

dstack/_internal/core/backends/digitalocean/backend.py

@@ -0,0 +1,16 @@
+from dstack._internal.core.backends.digitalocean.compute import DigitalOceanCompute
+from dstack._internal.core.backends.digitalocean_base.backend import BaseDigitalOceanBackend
+from dstack._internal.core.backends.digitalocean_base.models import BaseDigitalOceanConfig
+from dstack._internal.core.models.backends.base import BackendType
+
+
+class DigitalOceanBackend(BaseDigitalOceanBackend):
+    TYPE = BackendType.DIGITALOCEAN
+    COMPUTE_CLASS = DigitalOceanCompute
+
+    def __init__(self, config: BaseDigitalOceanConfig, api_url: str):
+        self.config = config
+        self._compute = DigitalOceanCompute(self.config, api_url=api_url, type=self.TYPE)
+
+    def compute(self) -> DigitalOceanCompute:
+        return self._compute

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

@@ -0,0 +1,5 @@
+from ..digitalocean_base.compute import BaseDigitalOceanCompute
+
+
+class DigitalOceanCompute(BaseDigitalOceanCompute):
+    pass

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

@@ -0,0 +1,31 @@
+from typing import Optional
+
+from dstack._internal.core.backends.base.configurator import BackendRecord
+from dstack._internal.core.backends.digitalocean.backend import DigitalOceanBackend
+from dstack._internal.core.backends.digitalocean_base.api_client import DigitalOceanAPIClient
+from dstack._internal.core.backends.digitalocean_base.backend import BaseDigitalOceanBackend
+from dstack._internal.core.backends.digitalocean_base.configurator import (
+    BaseDigitalOceanConfigurator,
+)
+from dstack._internal.core.backends.digitalocean_base.models import (
+    AnyBaseDigitalOceanCreds,
+)
+from dstack._internal.core.models.backends.base import (
+    BackendType,
+)
+
+
+class DigitalOceanConfigurator(BaseDigitalOceanConfigurator):
+    TYPE = BackendType.DIGITALOCEAN
+    BACKEND_CLASS = DigitalOceanBackend
+    API_URL = "https://api.digitalocean.com"
+
+    def get_backend(self, record: BackendRecord) -> BaseDigitalOceanBackend:
+        config = self._get_config(record)
+        return DigitalOceanBackend(config=config, api_url=self.API_URL)
+
+    def _validate_creds(self, creds: AnyBaseDigitalOceanCreds, project_name: Optional[str] = None):
+        api_client = DigitalOceanAPIClient(creds.api_key, self.API_URL)
+        api_client.validate_api_key()
+        if project_name:
+            api_client.validate_project_name(project_name)

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

@@ -0,0 +1 @@
+# This package contains the base classes for DigitalOcean and AMDDevCloud backends.

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

@@ -0,0 +1,104 @@
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from dstack._internal.core.backends.base.configurator import raise_invalid_credentials_error
+from dstack._internal.core.errors import NoCapacityError
+from dstack._internal.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class DigitalOceanAPIClient:
+    def __init__(self, api_key: str, api_url: str):
+        self.api_key = api_key
+        self.base_url = api_url
+
+    def validate_api_key(self) -> bool:
+        try:
+            response = self._make_request("GET", "/v2/account")
+            response.raise_for_status()
+            return True
+        except requests.HTTPError as e:
+            status = e.response.status_code
+            if status == 401:
+                raise_invalid_credentials_error(
+                    fields=[["creds", "api_key"]], details="Invaild API key"
+                )
+            raise e
+
+    def validate_project_name(self, project_name: str) -> bool:
+        if self.get_project_id(project_name) is None:
+            raise_invalid_credentials_error(
+                fields=[["project_name"]],
+                details=f"Project with name '{project_name}' does not exist",
+            )
+        return True
+
+    def list_ssh_keys(self) -> List[Dict[str, Any]]:
+        response = self._make_request("GET", "/v2/account/keys")
+        response.raise_for_status()
+        return response.json()["ssh_keys"]
+
+    def list_projects(self) -> List[Dict[str, Any]]:
+        response = self._make_request("GET", "/v2/projects")
+        response.raise_for_status()
+        return response.json()["projects"]
+
+    def get_project_id(self, project_name: str) -> Optional[str]:
+        projects = self.list_projects()
+        for project in projects:
+            if project["name"] == project_name:
+                return project["id"]
+        return None
+
+    def create_ssh_key(self, name: str, public_key: str) -> Dict[str, Any]:
+        payload = {"name": name, "public_key": public_key}
+        response = self._make_request("POST", "/v2/account/keys", json=payload)
+        response.raise_for_status()
+        return response.json()["ssh_key"]
+
+    def get_or_create_ssh_key(self, name: str, public_key: str) -> int:
+        ssh_keys = self.list_ssh_keys()
+        for ssh_key in ssh_keys:
+            if ssh_key["public_key"].strip() == public_key.strip():
+                return ssh_key["id"]
+
+        ssh_key = self.create_ssh_key(name, public_key)
+        return ssh_key["id"]
+
+    def create_droplet(self, droplet_config: Dict[str, Any]) -> Dict[str, Any]:
+        response = self._make_request("POST", "/v2/droplets", json=droplet_config)
+        if response.status_code == 422:
+            raise NoCapacityError(response.json()["message"])
+        response.raise_for_status()
+        return response.json()["droplet"]
+
+    def get_droplet(self, droplet_id: str) -> Dict[str, Any]:
+        response = self._make_request("GET", f"/v2/droplets/{droplet_id}")
+        response.raise_for_status()
+        return response.json()["droplet"]
+
+    def delete_droplet(self, droplet_id: str) -> None:
+        response = self._make_request("DELETE", f"/v2/droplets/{droplet_id}")
+        if response.status_code == 404:
+            logger.debug("DigitalOcean droplet %s not found", droplet_id)
+            return
+        response.raise_for_status()
+
+    def _make_request(
+        self, method: str, endpoint: str, json: Optional[Dict[str, Any]] = None, timeout: int = 30
+    ) -> requests.Response:
+        url = f"{self.base_url}{endpoint}"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        response = requests.request(
+            method=method,
+            url=url,
+            headers=headers,
+            json=json,
+            timeout=timeout,
+        )
+        return response

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

@@ -0,0 +1,5 @@
+from dstack._internal.core.backends.base.backend import Backend
+
+
+class BaseDigitalOceanBackend(Backend):
+    pass