dstack 0.18.43__py3-none-any.whl → 0.19.0__py3-none-any.whl

dstack/_internal/{server/services/backends/configurators/gcp.py → core/backends/gcp/configurator.py}

@@ -1,37 +1,30 @@
 import json
-from typing import List
 
 import google.cloud.compute_v1 as compute_v1
-from google.auth.credentials import Credentials
 
-from dstack._internal.core.backends.gcp import GCPBackend, auth, resources
-from dstack._internal.core.backends.gcp.config import GCPConfig
-from dstack._internal.core.errors import BackendAuthError, BackendError, ServerClientError
-from dstack._internal.core.models.backends.base import (
-    BackendType,
-    ConfigElement,
-    ConfigElementValue,
-    ConfigMultiElement,
+from dstack._internal.core.backends.base.configurator import (
+    TAGS_MAX_NUM,
+    BackendRecord,
+    Configurator,
+    raise_invalid_credentials_error,
 )
-from dstack._internal.core.models.backends.gcp import (
-    AnyGCPConfigInfo,
-    GCPConfigInfo,
-    GCPConfigInfoWithCreds,
-    GCPConfigInfoWithCredsPartial,
-    GCPConfigValues,
+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,
     GCPCreds,
     GCPDefaultCreds,
     GCPServiceAccountCreds,
     GCPStoredConfig,
 )
-from dstack._internal.core.models.common import is_core_model_instance
-from dstack._internal.server import settings
-from dstack._internal.server.models import BackendModel, DecryptedString, ProjectModel
-from dstack._internal.server.services.backends.configurators.base import (
-    TAGS_MAX_NUM,
-    Configurator,
-    raise_invalid_credentials_error,
+from dstack._internal.core.errors import BackendAuthError, BackendError, ServerClientError
+from dstack._internal.core.models.backends.base import (
+    BackendType,
 )
+from dstack._internal.core.models.common import is_core_model_instance
 
 LOCATIONS = [
     {
@@ -118,34 +111,11 @@ MAIN_REGION = "us-east1"
 
 
 class GCPConfigurator(Configurator):
-    TYPE: BackendType = BackendType.GCP
-
-    def get_default_configs(self) -> List[GCPConfigInfoWithCreds]:
-        if not auth.default_creds_available():
-            return []
-        try:
-            _, project_id = auth.authenticate(GCPDefaultCreds())
-        except BackendAuthError:
-            return []
-        return [
-            GCPConfigInfoWithCreds(
-                project_id=project_id,
-                regions=DEFAULT_REGIONS,
-                creds=GCPDefaultCreds(),
-            )
-        ]
+    TYPE = BackendType.GCP
+    BACKEND_CLASS = GCPBackend
 
-    def get_config_values(self, config: GCPConfigInfoWithCredsPartial) -> GCPConfigValues:
-        config_values = GCPConfigValues(project_id=None, regions=None)
-        config_values.default_creds = (
-            settings.DEFAULT_CREDS_ENABLED and auth.default_creds_available()
-        )
-        if config.creds is None:
-            return config_values
-        if (
-            is_core_model_instance(config.creds, GCPDefaultCreds)
-            and not settings.DEFAULT_CREDS_ENABLED
-        ):
+    def validate_config(self, config: GCPBackendConfigWithCreds, default_creds_enabled: bool):
+        if is_core_model_instance(config.creds, GCPDefaultCreds) and not default_creds_enabled:
             raise_invalid_credentials_error(fields=[["creds"]])
         try:
             credentials, _ = auth.authenticate(creds=config.creds, project_id=config.project_id)
@@ -157,73 +127,46 @@ class GCPConfigurator(Configurator):
                 raise_invalid_credentials_error(fields=[["creds", "data"]], details=details)
             else:
                 raise_invalid_credentials_error(fields=[["creds"]], details=details)
-        config_values.regions = self._get_regions_element(
-            selected=config.regions or DEFAULT_REGIONS
+        subnetworks_client = compute_v1.SubnetworksClient(credentials=credentials)
+        routers_client = compute_v1.RoutersClient(credentials=credentials)
+        self._check_config_tags(config)
+        self._check_config_vpc(
+            subnetworks_client=subnetworks_client,
+            routers_client=routers_client,
+            config=config,
         )
-        if config.project_id is None:
-            return config_values
-        config_values.project_id = self._get_project_id_element(selected=config.project_id)
-        self._check_config(config=config, credentials=credentials)
-        return config_values
 
     def create_backend(
-        self, project: ProjectModel, config: GCPConfigInfoWithCreds
-    ) -> BackendModel:
+        self, project_name: str, config: GCPBackendConfigWithCreds
+    ) -> BackendRecord:
         if config.regions is None:
             config.regions = DEFAULT_REGIONS
-        return BackendModel(
-            project_id=project.id,
-            type=self.TYPE.value,
+        return BackendRecord(
             config=GCPStoredConfig(
-                **GCPConfigInfo.__response__.parse_obj(config).dict(),
+                **GCPBackendConfig.__response__.parse_obj(config).dict(),
             ).json(),
-            auth=DecryptedString(plaintext=GCPCreds.parse_obj(config.creds).json()),
+            auth=GCPCreds.parse_obj(config.creds).json(),
         )
 
-    def get_config_info(self, model: BackendModel, include_creds: bool) -> AnyGCPConfigInfo:
-        config = self._get_backend_config(model)
+    def get_backend_config(
+        self, record: BackendRecord, include_creds: bool
+    ) -> AnyGCPBackendConfig:
+        config = self._get_config(record)
         if include_creds:
-            return GCPConfigInfoWithCreds.__response__.parse_obj(config)
-        return GCPConfigInfo.__response__.parse_obj(config)
+            return GCPBackendConfigWithCreds.__response__.parse_obj(config)
+        return GCPBackendConfig.__response__.parse_obj(config)
 
-    def get_backend(self, model: BackendModel) -> GCPBackend:
-        config = self._get_backend_config(model)
+    def get_backend(self, record: BackendRecord) -> GCPBackend:
+        config = self._get_config(record)
         return GCPBackend(config=config)
 
-    def _get_backend_config(self, model: BackendModel) -> GCPConfig:
+    def _get_config(self, record: BackendRecord) -> GCPConfig:
         return GCPConfig.__response__(
-            **json.loads(model.config),
-            creds=GCPCreds.parse_raw(model.auth.get_plaintext_or_error()).__root__,
-        )
-
-    def _get_project_id_element(
-        self,
-        selected: str,
-    ) -> ConfigElement:
-        element = ConfigElement(selected=selected)
-        element.values.append(ConfigElementValue(value=selected, label=selected))
-        return element
-
-    def _get_regions_element(
-        self,
-        selected: List[str],
-    ) -> ConfigMultiElement:
-        element = ConfigMultiElement(selected=selected)
-        for region_name in REGIONS:
-            element.values.append(ConfigElementValue(value=region_name, label=region_name))
-        return element
-
-    def _check_config(self, config: GCPConfigInfoWithCredsPartial, credentials: Credentials):
-        subnetworks_client = compute_v1.SubnetworksClient(credentials=credentials)
-        routers_client = compute_v1.RoutersClient(credentials=credentials)
-        self._check_tags_config(config)
-        self._check_vpc_config(
-            subnetworks_client=subnetworks_client,
-            routers_client=routers_client,
-            config=config,
+            **json.loads(record.config),
+            creds=GCPCreds.parse_raw(record.auth).__root__,
         )
 
-    def _check_tags_config(self, config: GCPConfigInfoWithCredsPartial):
+    def _check_config_tags(self, config: GCPBackendConfigWithCreds):
         if not config.tags:
             return
         if len(config.tags) > TAGS_MAX_NUM:
@@ -235,9 +178,9 @@ class GCPConfigurator(Configurator):
         except BackendError as e:
             raise ServerClientError(e.args[0])
 
-    def _check_vpc_config(
+    def _check_config_vpc(
         self,
-        config: GCPConfigInfoWithCredsPartial,
+        config: GCPBackendConfigWithCreds,
         subnetworks_client: compute_v1.SubnetworksClient,
         routers_client: compute_v1.RoutersClient,
     ):

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

@@ -0,0 +1,125 @@
+from typing import Annotated, Dict, List, Literal, Optional, Union
+
+from pydantic import Field, root_validator
+
+from dstack._internal.core.backends.base.models import fill_data
+from dstack._internal.core.models.common import CoreModel
+
+
+class GCPServiceAccountCreds(CoreModel):
+    type: Annotated[Literal["service_account"], Field(description="The type of credentials")] = (
+        "service_account"
+    )
+    filename: Annotated[
+        Optional[str], Field(description="The path to the service account file")
+    ] = ""
+    data: Annotated[str, Field(description="The contents of the service account file")]
+
+
+class GCPDefaultCreds(CoreModel):
+    type: Literal["default"] = "default"
+
+
+AnyGCPCreds = Union[GCPServiceAccountCreds, GCPDefaultCreds]
+
+
+class GCPCreds(CoreModel):
+    __root__: AnyGCPCreds = Field(..., discriminator="type")
+
+
+class GCPBackendConfig(CoreModel):
+    type: Annotated[Literal["gcp"], Field(description="The type of backend")] = "gcp"
+    project_id: Annotated[str, Field(description="The project ID")]
+    regions: Annotated[
+        Optional[List[str]], Field(description="The list of GCP regions. Omit to use all regions")
+    ] = None
+    vpc_name: Annotated[Optional[str], Field(description="The name of a custom VPC")] = None
+    vpc_project_id: Annotated[
+        Optional[str],
+        Field(description="The shared VPC hosted project ID. Required for shared VPC only"),
+    ] = None
+    public_ips: Annotated[
+        Optional[bool],
+        Field(
+            description="A flag to enable/disable public IP assigning on instances. Defaults to `true`"
+        ),
+    ] = None
+    nat_check: Annotated[
+        Optional[bool],
+        Field(
+            description=(
+                "A flag to enable/disable a check that Cloud NAT is configured for the VPC."
+                " This should be set to `false` when `public_ips: false` and outbound internet connectivity"
+                " is provided by a mechanism other than Cloud NAT such as a third-party NAT appliance."
+                " Defaults to `true`"
+            )
+        ),
+    ] = None
+    vm_service_account: Annotated[
+        Optional[str], Field(description="The service account to associate with provisioned VMs")
+    ] = None
+    tags: Annotated[
+        Optional[Dict[str, str]],
+        Field(
+            description="The tags (labels) that will be assigned to resources created by `dstack`"
+        ),
+    ] = None
+
+
+class GCPBackendConfigWithCreds(GCPBackendConfig):
+    creds: AnyGCPCreds = Field(..., description="The credentials", discriminator="type")
+
+
+class GCPServiceAccountFileCreds(CoreModel):
+    type: Annotated[Literal["service_account"], Field(description="The type of credentials")] = (
+        "service_account"
+    )
+    filename: Annotated[str, Field(description="The path to the service account file")]
+    data: Annotated[
+        Optional[str],
+        Field(
+            description=(
+                "The contents of the service account file."
+                " When configuring via `server/config.yml`, it's automatically filled from `filename`."
+                " When configuring via UI, it has to be specified explicitly"
+            )
+        ),
+    ] = None
+
+    @root_validator
+    def fill_data(cls, values):
+        return fill_data(values)
+
+
+AnyGCPFileCreds = Union[GCPServiceAccountFileCreds, GCPDefaultCreds]
+
+
+class GCPBackendFileConfigWithCreds(GCPBackendConfig):
+    creds: AnyGCPFileCreds = Field(..., description="The credentials", discriminator="type")
+
+
+AnyGCPBackendConfig = Union[GCPBackendConfig, GCPBackendConfigWithCreds]
+
+
+class GCPStoredConfig(GCPBackendConfig):
+    pass
+
+
+class GCPConfig(GCPStoredConfig):
+    creds: AnyGCPCreds
+
+    @property
+    def allocate_public_ips(self) -> bool:
+        if self.public_ips is not None:
+            return self.public_ips
+        return True
+
+    @property
+    def vpc_resource_name(self) -> str:
+        vpc_name = self.vpc_name
+        if vpc_name is None:
+            vpc_name = "default"
+        project_id = self.project_id
+        if self.vpc_project_id is not None:
+            project_id = self.vpc_project_id
+        return f"projects/{project_id}/global/networks/{vpc_name}"

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

@@ -1,15 +0,0 @@
-from dstack._internal.core.backends.base import Backend
-from dstack._internal.core.backends.kubernetes.compute import KubernetesCompute
-from dstack._internal.core.backends.kubernetes.config import KubernetesConfig
-from dstack._internal.core.models.backends.base import BackendType
-
-
-class KubernetesBackend(Backend):
-    TYPE: BackendType = BackendType.KUBERNETES
-
-    def __init__(self, config: KubernetesConfig):
-        self.config = config
-        self._compute = KubernetesCompute(self.config)
-
-    def compute(self) -> KubernetesCompute:
-        return self._compute

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

@@ -0,0 +1,16 @@
+from dstack._internal.core.backends.base.backend import Backend
+from dstack._internal.core.backends.kubernetes.compute import KubernetesCompute
+from dstack._internal.core.backends.kubernetes.models import KubernetesConfig
+from dstack._internal.core.models.backends.base import BackendType
+
+
+class KubernetesBackend(Backend):
+    TYPE = BackendType.KUBERNETES
+    COMPUTE_CLASS = KubernetesCompute
+
+    def __init__(self, config: KubernetesConfig):
+        self.config = config
+        self._compute = KubernetesCompute(self.config)
+
+    def compute(self) -> KubernetesCompute:
+        return self._compute

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

@@ -9,13 +9,17 @@ from kubernetes import client
 
 from dstack._internal.core.backends.base.compute import (
     Compute,
+    ComputeWithGatewaySupport,
     generate_unique_gateway_instance_name,
     generate_unique_instance_name_for_job,
     get_docker_commands,
     get_dstack_gateway_commands,
 )
 from dstack._internal.core.backends.base.offers import match_requirements
-from dstack._internal.core.backends.kubernetes.config import KubernetesConfig
+from dstack._internal.core.backends.kubernetes.models import (
+    KubernetesConfig,
+    KubernetesNetworkingConfig,
+)
 from dstack._internal.core.backends.kubernetes.utils import (
     get_api_from_config_data,
     get_cluster_public_ip,
@@ -53,10 +57,17 @@ NVIDIA_GPU_NAME_TO_GPU_INFO = {gpu.name: gpu for gpu in KNOWN_NVIDIA_GPUS}
 NVIDIA_GPU_NAMES = NVIDIA_GPU_NAME_TO_GPU_INFO.keys()
 
 
-class KubernetesCompute(Compute):
+class KubernetesCompute(
+    ComputeWithGatewaySupport,
+    Compute,
+):
     def __init__(self, config: KubernetesConfig):
         super().__init__()
-        self.config = config
+        self.config = config.copy()
+        networking_config = self.config.networking
+        if networking_config is None:
+            networking_config = KubernetesNetworkingConfig()
+        self.networking_config = networking_config
         self.api = get_api_from_config_data(config.kubeconfig.data)
 
     def get_offers(
@@ -109,7 +120,7 @@ class KubernetesCompute(Compute):
         # as an ssh proxy jump to connect to all other services in Kubernetes.
         # Setup jump pod in a separate thread to avoid long-running run_job.
         # In case the thread fails, the job will be failed and resubmitted.
-        jump_pod_hostname = self.config.networking.ssh_host
+        jump_pod_hostname = self.networking_config.ssh_host
         if jump_pod_hostname is None:
             jump_pod_hostname = get_cluster_public_ip(self.api)
             if jump_pod_hostname is None:
@@ -121,7 +132,7 @@ class KubernetesCompute(Compute):
             api=self.api,
             project_name=run.project_name,
             ssh_public_keys=[project_ssh_public_key.strip(), run.run_spec.ssh_key_pub.strip()],
-            jump_pod_port=self.config.networking.ssh_port,
+            jump_pod_port=self.networking_config.ssh_port,
         )
         if not created:
             threading.Thread(

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

@@ -0,0 +1,55 @@
+from dstack._internal.core.backends.base.configurator import (
+    BackendRecord,
+    Configurator,
+    raise_invalid_credentials_error,
+)
+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,
+    KubernetesStoredConfig,
+)
+from dstack._internal.core.models.backends.base import BackendType
+from dstack._internal.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class KubernetesConfigurator(Configurator):
+    TYPE = BackendType.KUBERNETES
+    BACKEND_CLASS = KubernetesBackend
+
+    def validate_config(
+        self, config: KubernetesBackendConfigWithCreds, default_creds_enabled: bool
+    ):
+        try:
+            api = kubernetes_utils.get_api_from_config_data(config.kubeconfig.data)
+            api.list_node()
+        except Exception as e:
+            logger.debug("Invalid kubeconfig: %s", str(e))
+            raise_invalid_credentials_error(fields=[["kubeconfig"]])
+
+    def create_backend(
+        self, project_name: str, config: KubernetesBackendConfigWithCreds
+    ) -> BackendRecord:
+        return BackendRecord(
+            config=KubernetesStoredConfig.__response__.parse_obj(config).json(),
+            auth="",
+        )
+
+    def get_backend_config(
+        self, record: BackendRecord, include_creds: bool
+    ) -> AnyKubernetesBackendConfig:
+        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:
+        return KubernetesBackend(self._get_config(record))
+
+    def _get_config(self, record: BackendRecord) -> KubernetesConfig:
+        return KubernetesConfig.__response__.parse_raw(record.config)

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

@@ -0,0 +1,72 @@
+from typing import Annotated, Literal, Optional, Union
+
+from pydantic import Field, root_validator
+
+from dstack._internal.core.backends.base.models import fill_data
+from dstack._internal.core.models.common import CoreModel
+
+
+class KubernetesNetworkingConfig(CoreModel):
+    ssh_host: Annotated[
+        Optional[str], Field(description="The external IP address of any node")
+    ] = None
+    ssh_port: Annotated[
+        Optional[int], Field(description="Any port accessible outside of the cluster")
+    ] = None
+
+
+class KubeconfigConfig(CoreModel):
+    filename: Annotated[str, Field(description="The path to the kubeconfig file")] = ""
+    data: Annotated[str, Field(description="The contents of the kubeconfig file")]
+
+
+class KubernetesBackendConfig(CoreModel):
+    type: Annotated[Literal["kubernetes"], Field(description="The type of backend")] = "kubernetes"
+    networking: Annotated[
+        Optional[KubernetesNetworkingConfig], Field(description="The networking configuration")
+    ] = None
+
+
+class KubernetesBackendConfigWithCreds(CoreModel):
+    type: Annotated[Literal["kubernetes"], Field(description="The type of backend")] = "kubernetes"
+    networking: Annotated[
+        Optional[KubernetesNetworkingConfig], Field(description="The networking configuration")
+    ] = None
+    kubeconfig: Annotated[KubeconfigConfig, Field(description="The kubeconfig configuration")]
+
+
+class KubeconfigFileConfig(CoreModel):
+    filename: Annotated[str, Field(description="The path to the kubeconfig file")]
+    data: Annotated[
+        Optional[str],
+        Field(
+            description=(
+                "The contents of the kubeconfig file."
+                " When configuring via `server/config.yml`, it's automatically filled from `filename`."
+                " When configuring via UI, it has to be specified explicitly"
+            )
+        ),
+    ] = None
+
+    @root_validator
+    def fill_data(cls, values):
+        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
+    kubeconfig: Annotated[KubeconfigFileConfig, Field(description="The kubeconfig configuration")]
+
+
+AnyKubernetesBackendConfig = Union[KubernetesBackendConfig, KubernetesBackendConfigWithCreds]
+
+
+class KubernetesStoredConfig(KubernetesBackendConfigWithCreds):
+    pass
+
+
+class KubernetesConfig(KubernetesStoredConfig):
+    pass

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

@@ -1,16 +0,0 @@
-from dstack._internal.core.backends.base import Backend
-from dstack._internal.core.backends.lambdalabs.compute import LambdaCompute
-from dstack._internal.core.backends.lambdalabs.config import LambdaConfig
-from dstack._internal.core.models.backends.base import BackendType
-
-
-class LambdaBackend(Backend):
-    TYPE: BackendType = BackendType.LAMBDA
-
-    def __init__(self, config: LambdaConfig):
-        self.config = config
-        self._compute = LambdaCompute(self.config)
-        # self._check_credentials()
-
-    def compute(self) -> LambdaCompute:
-        return self._compute

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

@@ -0,0 +1,17 @@
+from dstack._internal.core.backends.base.backend import Backend
+from dstack._internal.core.backends.lambdalabs.compute import LambdaCompute
+from dstack._internal.core.backends.lambdalabs.models import LambdaConfig
+from dstack._internal.core.models.backends.base import BackendType
+
+
+class LambdaBackend(Backend):
+    TYPE = BackendType.LAMBDA
+    COMPUTE_CLASS = LambdaCompute
+
+    def __init__(self, config: LambdaConfig):
+        self.config = config
+        self._compute = LambdaCompute(self.config)
+        # self._check_credentials()
+
+    def compute(self) -> LambdaCompute:
+        return self._compute

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

@@ -6,28 +6,29 @@ from typing import Dict, List, Optional
 
 from dstack._internal.core.backends.base.compute import (
     Compute,
+    ComputeWithCreateInstanceSupport,
     generate_unique_instance_name,
-    get_job_instance_name,
     get_shim_commands,
 )
 from dstack._internal.core.backends.base.offers import get_catalog_offers
 from dstack._internal.core.backends.lambdalabs.api_client import LambdaAPIClient
-from dstack._internal.core.backends.lambdalabs.config import LambdaConfig
+from dstack._internal.core.backends.lambdalabs.models import LambdaConfig
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.instances import (
     InstanceAvailability,
     InstanceConfiguration,
     InstanceOffer,
     InstanceOfferWithAvailability,
-    SSHKey,
 )
-from dstack._internal.core.models.runs import Job, JobProvisioningData, Requirements, Run
-from dstack._internal.core.models.volumes import Volume
+from dstack._internal.core.models.runs import JobProvisioningData, Requirements
 
 MAX_INSTANCE_NAME_LEN = 60
 
 
-class LambdaCompute(Compute):
+class LambdaCompute(
+    ComputeWithCreateInstanceSupport,
+    Compute,
+):
     def __init__(self, config: LambdaConfig):
         super().__init__()
         self.config = config
@@ -102,28 +103,6 @@ class LambdaCompute(Compute):
             )
             thread.start()
 
-    def run_job(
-        self,
-        run: Run,
-        job: Job,
-        instance_offer: InstanceOfferWithAvailability,
-        project_ssh_public_key: str,
-        project_ssh_private_key: str,
-        volumes: List[Volume],
-    ) -> JobProvisioningData:
-        instance_config = InstanceConfiguration(
-            project_name=run.project_name,
-            instance_name=get_job_instance_name(run, job),  # TODO: generate name
-            ssh_keys=[
-                SSHKey(
-                    public=project_ssh_public_key.strip(), private=project_ssh_private_key.strip()
-                ),
-                SSHKey(public=run.run_spec.ssh_key_pub.strip()),
-            ],
-            user=run.user,
-        )
-        return self.create_instance(instance_offer, instance_config)
-
     def terminate_instance(
         self, instance_id: str, region: str, backend_data: Optional[str] = None
     ):