dstack 0.19.15rc1__py3-none-any.whl → 0.19.17__py3-none-any.whl

dstack/_internal/cli/commands/secrets.py

@@ -0,0 +1,92 @@
+import argparse
+
+from dstack._internal.cli.commands import APIBaseCommand
+from dstack._internal.cli.services.completion import SecretNameCompleter
+from dstack._internal.cli.utils.common import (
+    confirm_ask,
+    console,
+)
+from dstack._internal.cli.utils.secrets import print_secrets_table
+
+
+class SecretCommand(APIBaseCommand):
+    NAME = "secret"
+    DESCRIPTION = "Manage secrets"
+
+    def _register(self):
+        super()._register()
+        self._parser.set_defaults(subfunc=self._list)
+        subparsers = self._parser.add_subparsers(dest="action")
+
+        list_parser = subparsers.add_parser(
+            "list", help="List secrets", formatter_class=self._parser.formatter_class
+        )
+        list_parser.set_defaults(subfunc=self._list)
+
+        get_parser = subparsers.add_parser(
+            "get", help="Get secret value", formatter_class=self._parser.formatter_class
+        )
+        get_parser.add_argument(
+            "name",
+            help="The name of the secret",
+        ).completer = SecretNameCompleter()
+        get_parser.set_defaults(subfunc=self._get)
+
+        set_parser = subparsers.add_parser(
+            "set", help="Set secret", formatter_class=self._parser.formatter_class
+        )
+        set_parser.add_argument(
+            "name",
+            help="The name of the secret",
+        )
+        set_parser.add_argument(
+            "value",
+            help="The value of the secret",
+        )
+        set_parser.set_defaults(subfunc=self._set)
+
+        delete_parser = subparsers.add_parser(
+            "delete",
+            help="Delete secrets",
+            formatter_class=self._parser.formatter_class,
+        )
+        delete_parser.add_argument(
+            "name",
+            help="The name of the secret",
+        ).completer = SecretNameCompleter()
+        delete_parser.add_argument(
+            "-y", "--yes", help="Don't ask for confirmation", action="store_true"
+        )
+        delete_parser.set_defaults(subfunc=self._delete)
+
+    def _command(self, args: argparse.Namespace):
+        super()._command(args)
+        args.subfunc(args)
+
+    def _list(self, args: argparse.Namespace):
+        secrets = self.api.client.secrets.list(self.api.project)
+        print_secrets_table(secrets)
+
+    def _get(self, args: argparse.Namespace):
+        secret = self.api.client.secrets.get(self.api.project, name=args.name)
+        print_secrets_table([secret])
+
+    def _set(self, args: argparse.Namespace):
+        self.api.client.secrets.create_or_update(
+            self.api.project,
+            name=args.name,
+            value=args.value,
+        )
+        console.print("[grey58]OK[/]")
+
+    def _delete(self, args: argparse.Namespace):
+        if not args.yes and not confirm_ask(f"Delete the secret [code]{args.name}[/]?"):
+            console.print("\nExiting...")
+            return
+
+        with console.status("Deleting secret..."):
+            self.api.client.secrets.delete(
+                project_name=self.api.project,
+                names=[args.name],
+            )
+        console.print("[grey58]OK[/]")

dstack/_internal/cli/main.py

@@ -17,6 +17,7 @@ from dstack._internal.cli.commands.metrics import MetricsCommand
 from dstack._internal.cli.commands.offer import OfferCommand
 from dstack._internal.cli.commands.project import ProjectCommand
 from dstack._internal.cli.commands.ps import PsCommand
+from dstack._internal.cli.commands.secrets import SecretCommand
 from dstack._internal.cli.commands.server import ServerCommand
 from dstack._internal.cli.commands.stats import StatsCommand
 from dstack._internal.cli.commands.stop import StopCommand
@@ -72,6 +73,7 @@ def main():
     MetricsCommand.register(subparsers)
     ProjectCommand.register(subparsers)
     PsCommand.register(subparsers)
+    SecretCommand.register(subparsers)
     ServerCommand.register(subparsers)
     StatsCommand.register(subparsers)
     StopCommand.register(subparsers)

dstack/_internal/cli/services/completion.py

@@ -75,6 +75,11 @@ class GatewayNameCompleter(BaseAPINameCompleter):
         return [r.name for r in api.client.gateways.list(api.project)]
 
 
+class SecretNameCompleter(BaseAPINameCompleter):
+    def fetch_resource_names(self, api: Client) -> Iterable[str]:
+        return [r.name for r in api.client.secrets.list(api.project)]
+
+
 class ProjectNameCompleter(BaseCompleter):
     """
     Completer for local project names.

dstack/_internal/cli/services/configurators/run.py

@@ -41,12 +41,13 @@ from dstack._internal.core.models.configurations import (
 )
 from dstack._internal.core.models.repos.base import Repo
 from dstack._internal.core.models.resources import CPUSpec
-from dstack._internal.core.models.runs import JobStatus, JobSubmission, RunStatus
+from dstack._internal.core.models.runs import JobStatus, JobSubmission, RunSpec, RunStatus
 from dstack._internal.core.services.configs import ConfigManager
 from dstack._internal.core.services.diff import diff_models
 from dstack._internal.utils.common import local_time
 from dstack._internal.utils.interpolator import InterpolatorError, VariablesInterpolator
 from dstack._internal.utils.logging import get_logger
+from dstack._internal.utils.nested_list import NestedList, NestedListItem
 from dstack.api._public.repos import get_ssh_keypair
 from dstack.api._public.runs import Run
 from dstack.api.utils import load_profile
@@ -102,25 +103,20 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
             confirm_message = f"Submit the run [code]{conf.name}[/]?"
         stop_run_name = None
         if run_plan.current_resource is not None:
-            changed_fields = []
-            if run_plan.action == ApplyAction.UPDATE:
-                diff = diff_models(
-                    run_plan.get_effective_run_spec().configuration,
-                    run_plan.current_resource.run_spec.configuration,
-                )
-                changed_fields = list(diff.keys())
-            if run_plan.action == ApplyAction.UPDATE and len(changed_fields) > 0:
+            diff = render_run_spec_diff(
+                run_plan.get_effective_run_spec(),
+                run_plan.current_resource.run_spec,
+            )
+            if run_plan.action == ApplyAction.UPDATE and diff is not None:
                 console.print(
                     f"Active run [code]{conf.name}[/] already exists."
-                    " Detected configuration changes that can be updated in-place:"
-                    f" {changed_fields}"
+                    f" Detected changes that [code]can[/] be updated in-place:\n{diff}"
                 )
                 confirm_message = "Update the run?"
-            elif run_plan.action == ApplyAction.UPDATE and len(changed_fields) == 0:
+            elif run_plan.action == ApplyAction.UPDATE and diff is None:
                 stop_run_name = run_plan.current_resource.run_spec.run_name
                 console.print(
-                    f"Active run [code]{conf.name}[/] already exists."
-                    " Detected no configuration changes."
+                    f"Active run [code]{conf.name}[/] already exists. Detected no changes."
                 )
                 if command_args.yes and not command_args.force:
                     console.print("Use --force to apply anyway.")
@@ -129,7 +125,8 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
             elif not run_plan.current_resource.status.is_finished():
                 stop_run_name = run_plan.current_resource.run_spec.run_name
                 console.print(
-                    f"Active run [code]{conf.name}[/] already exists and cannot be updated in-place."
+                    f"Active run [code]{conf.name}[/] already exists."
+                    f" Detected changes that [error]cannot[/] be updated in-place:\n{diff}"
                 )
                 confirm_message = "Stop and override the run?"
 
@@ -398,9 +395,10 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
         else:
             has_amd_gpu = vendor == gpuhunt.AcceleratorVendor.AMD
             has_tt_gpu = vendor == gpuhunt.AcceleratorVendor.TENSTORRENT
-        if has_amd_gpu and conf.image is None:
+        # When docker=True, the system uses Docker-in-Docker image, so no custom image is required
+        if has_amd_gpu and conf.image is None and conf.docker is not True:
             raise ConfigurationError("`image` is required if `resources.gpu.vendor` is `amd`")
-        if has_tt_gpu and conf.image is None:
+        if has_tt_gpu and conf.image is None and conf.docker is not True:
             raise ConfigurationError(
                 "`image` is required if `resources.gpu.vendor` is `tenstorrent`"
             )
@@ -610,3 +608,47 @@ def _run_resubmitted(run: Run, current_job_submission: Optional[JobSubmission])
         not run.status.is_finished()
         and run._run.latest_job_submission.submitted_at > current_job_submission.submitted_at
     )
+
+
+def render_run_spec_diff(old_spec: RunSpec, new_spec: RunSpec) -> Optional[str]:
+    changed_spec_fields = list(diff_models(old_spec, new_spec))
+    if not changed_spec_fields:
+        return None
+    friendly_spec_field_names = {
+        "repo_id": "Repo ID",
+        "repo_code_hash": "Repo files",
+        "repo_data": "Repo state (branch, commit, or other)",
+        "ssh_key_pub": "Public SSH key",
+    }
+    nested_list = NestedList()
+    for spec_field in changed_spec_fields:
+        if spec_field == "merged_profile":
+            continue
+        elif spec_field == "configuration":
+            if type(old_spec.configuration) is not type(new_spec.configuration):
+                item = NestedListItem("Configuration type")
+            else:
+                item = NestedListItem(
+                    "Configuration properties:",
+                    children=[
+                        NestedListItem(field)
+                        for field in diff_models(old_spec.configuration, new_spec.configuration)
+                    ],
+                )
+        elif spec_field == "profile":
+            if type(old_spec.profile) is not type(new_spec.profile):
+                item = NestedListItem("Profile")
+            else:
+                item = NestedListItem(
+                    "Profile properties:",
+                    children=[
+                        NestedListItem(field)
+                        for field in diff_models(old_spec.profile, new_spec.profile)
+                    ],
+                )
+        elif spec_field in friendly_spec_field_names:
+            item = NestedListItem(friendly_spec_field_names[spec_field])
+        else:
+            item = NestedListItem(spec_field.replace("_", " ").capitalize())
+        nested_list.children.append(item)
+    return nested_list.render()

dstack/_internal/cli/utils/secrets.py

@@ -0,0 +1,25 @@
+from typing import List
+
+from rich.table import Table
+
+from dstack._internal.cli.utils.common import add_row_from_dict, console
+from dstack._internal.core.models.secrets import Secret
+
+
+def print_secrets_table(secrets: List[Secret]) -> None:
+    console.print(get_secrets_table(secrets))
+    console.print()
+
+
+def get_secrets_table(secrets: List[Secret]) -> Table:
+    table = Table(box=None)
+    table.add_column("NAME", no_wrap=True)
+    table.add_column("VALUE")
+
+    for secret in secrets:
+        row = {
+            "NAME": secret.name,
+            "VALUE": secret.value or "*" * 6,
+        }
+        add_row_from_dict(table, row)
+    return table

dstack/_internal/core/backends/__init__.py

@@ -9,18 +9,25 @@ from dstack._internal.core.backends.base.compute import (
 )
 from dstack._internal.core.backends.base.configurator import Configurator
 from dstack._internal.core.backends.configurators import list_available_configurator_classes
+from dstack._internal.core.backends.local.compute import LocalCompute
 from dstack._internal.core.models.backends.base import BackendType
+from dstack._internal.settings import LOCAL_BACKEND_ENABLED
 
 
 def _get_backends_with_compute_feature(
     configurator_classes: list[type[Configurator]],
     compute_feature_class: type,
 ) -> list[BackendType]:
+    backend_types_and_computes = [
+        (configurator_class.TYPE, configurator_class.BACKEND_CLASS.COMPUTE_CLASS)
+        for configurator_class in configurator_classes
+    ]
+    if LOCAL_BACKEND_ENABLED:
+        backend_types_and_computes.append((BackendType.LOCAL, LocalCompute))
     backend_types = []
-    for configurator_class in configurator_classes:
-        compute_class = configurator_class.BACKEND_CLASS.COMPUTE_CLASS
+    for backend_type, compute_class in backend_types_and_computes:
         if issubclass(compute_class, compute_feature_class):
-            backend_types.append(configurator_class.TYPE)
+            backend_types.append(backend_type)
     return backend_types
 
 
@@ -28,7 +35,6 @@ _configurator_classes = list_available_configurator_classes()
 
 
 # The following backend lists do not include unavailable backends (i.e. backends missing deps).
-# TODO: Add LocalBackend to lists if it's enabled
 BACKENDS_WITH_CREATE_INSTANCE_SUPPORT = _get_backends_with_compute_feature(
     configurator_classes=_configurator_classes,
     compute_feature_class=ComputeWithCreateInstanceSupport,

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

@@ -0,0 +1,208 @@
+import os
+import re
+from typing import Any, Dict, List, Mapping, Optional, Union
+
+import requests
+from packaging import version
+from requests import Response
+
+from dstack._internal.core.errors import BackendError, BackendInvalidCredentialsError
+from dstack._internal.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+CLOUDRIFT_SERVER_ADDRESS = "https://api.cloudrift.ai"
+CLOUDRIFT_API_VERSION = "2025-05-29"
+
+
+class RiftClient:
+    def __init__(self, api_key: Optional[str] = None):
+        self.public_api_root = os.path.join(CLOUDRIFT_SERVER_ADDRESS, "api/v1")
+        self.api_key = api_key
+
+    def validate_api_key(self) -> bool:
+        """
+        Validates the API key by making a request to the server.
+        Returns True if the API key is valid, False otherwise.
+        """
+        try:
+            response = self._make_request("auth/me")
+            if isinstance(response, dict):
+                return "email" in response
+            return False
+        except BackendInvalidCredentialsError:
+            return False
+        except Exception as e:
+            logger.error(f"Error validating API key: {e}")
+            return False
+
+    def get_instance_types(self) -> List[Dict]:
+        request_data = {"selector": {"ByServiceAndLocation": {"services": ["vm"]}}}
+        response_data = self._make_request("instance-types/list", request_data)
+        if isinstance(response_data, dict):
+            return response_data.get("instance_types", [])
+        return []
+
+    def list_recipes(self) -> List[Dict]:
+        request_data = {}
+        response_data = self._make_request("recipes/list", request_data)
+        if isinstance(response_data, dict):
+            return response_data.get("groups", [])
+        return []
+
+    def get_vm_recipies(self) -> List[Dict]:
+        """
+        Retrieves a list of VM recipes from the CloudRift API.
+        Returns a list of dictionaries containing recipe information.
+        """
+        recipe_group = self.list_recipes()
+        vm_recipes = []
+        for group in recipe_group:
+            tags = group.get("tags", [])
+            has_vm = "vm" in map(str.lower, tags)
+            if group.get("name", "").lower() != "linux" or not has_vm:
+                continue
+
+            recipes = group.get("recipes", [])
+            for recipe in recipes:
+                details = recipe.get("details", {})
+                if details.get("VirtualMachine", False):
+                    vm_recipes.append(recipe)
+
+        return vm_recipes
+
+    def get_vm_image_url(self) -> Optional[str]:
+        recipes = self.get_vm_recipies()
+        ubuntu_images = []
+        for recipe in recipes:
+            has_nvidia_driver = "nvidia-driver" in recipe.get("tags", [])
+            if not has_nvidia_driver:
+                continue
+
+            recipe_name = recipe.get("name", "")
+            if "Ubuntu" not in recipe_name:
+                continue
+
+            url = recipe["details"].get("VirtualMachine", {}).get("image_url", None)
+            version_match = re.search(r".* (\d+\.\d+)", recipe_name)
+            if url and version_match and version_match.group(1):
+                ubuntu_version = version.parse(version_match.group(1))
+                ubuntu_images.append((ubuntu_version, url))
+
+        ubuntu_images.sort(key=lambda x: x[0])  # Sort by version
+        if ubuntu_images:
+            return ubuntu_images[-1][1]
+
+        return None
+
+    def deploy_instance(
+        self, instance_type: str, region: str, ssh_keys: List[str], cmd: str
+    ) -> List[str]:
+        image_url = self.get_vm_image_url()
+        if not image_url:
+            raise BackendError("No suitable VM image found.")
+
+        request_data = {
+            "config": {
+                "VirtualMachine": {
+                    "cloudinit_commands": cmd,
+                    "image_url": image_url,
+                    "ssh_key": {"PublicKeys": ssh_keys},
+                }
+            },
+            "selector": {
+                "ByInstanceTypeAndLocation": {
+                    "datacenters": [region],
+                    "instance_type": instance_type,
+                }
+            },
+            "with_public_ip": True,
+        }
+        logger.debug("Deploying instance with request data: %s", request_data)
+
+        response_data = self._make_request("instances/rent", request_data)
+        if isinstance(response_data, dict):
+            return response_data.get("instance_ids", [])
+        return []
+
+    def list_instances(self, instance_ids: Optional[List[str]] = None) -> List[Dict]:
+        request_data = {
+            "selector": {
+                "ByStatus": ["Initializing", "Active", "Deactivating"],
+            }
+        }
+        logger.debug("Listing instances with request data: %s", request_data)
+        response_data = self._make_request("instances/list", request_data)
+        if isinstance(response_data, dict):
+            return response_data.get("instances", [])
+
+        return []
+
+    def get_instance_by_id(self, instance_id: str) -> Optional[Dict]:
+        request_data = {"selector": {"ById": [instance_id]}}
+        logger.debug("Getting instance with request data: %s", request_data)
+        response_data = self._make_request("instances/list", request_data)
+        if isinstance(response_data, dict):
+            instances = response_data.get("instances", [])
+            if isinstance(instances, list) and len(instances) > 0:
+                return instances[0]
+
+        return None
+
+    def terminate_instance(self, instance_id: str) -> bool:
+        request_data = {"selector": {"ById": [instance_id]}}
+        logger.debug("Terminating instance with request data: %s", request_data)
+        response_data = self._make_request("instances/terminate", request_data)
+        if isinstance(response_data, dict):
+            info = response_data.get("terminated", [])
+            return len(info) > 0
+
+        return False
+
+    def _make_request(
+        self,
+        endpoint: str,
+        data: Optional[Mapping[str, Any]] = None,
+        method: str = "POST",
+        **kwargs,
+    ) -> Union[Mapping[str, Any], str, Response]:
+        headers = {}
+        if self.api_key is not None:
+            headers["X-API-Key"] = self.api_key
+
+        version = CLOUDRIFT_API_VERSION
+        full_url = f"{self.public_api_root}/{endpoint}"
+
+        try:
+            response = requests.request(
+                method,
+                full_url,
+                headers=headers,
+                json={"version": version, "data": data},
+                timeout=15,
+                **kwargs,
+            )
+
+            if not response.ok:
+                response.raise_for_status()
+            try:
+                response_json = response.json()
+                if isinstance(response_json, str):
+                    return response_json
+                if version is not None and version < response_json["version"]:
+                    logger.warning(
+                        "The API version %s is lower than the server version %s. ",
+                        version,
+                        response_json["version"],
+                    )
+                return response_json["data"]
+            except requests.exceptions.JSONDecodeError:
+                return response
+        except requests.HTTPError as e:
+            if e.response is not None and e.response.status_code in (
+                requests.codes.forbidden,
+                requests.codes.unauthorized,
+            ):
+                raise BackendInvalidCredentialsError(e.response.text)
+            raise

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

@@ -0,0 +1,16 @@
+from dstack._internal.core.backends.base.backend import Backend
+from dstack._internal.core.backends.cloudrift.compute import CloudRiftCompute
+from dstack._internal.core.backends.cloudrift.models import CloudRiftConfig
+from dstack._internal.core.models.backends.base import BackendType
+
+
+class CloudRiftBackend(Backend):
+    TYPE = BackendType.CLOUDRIFT
+    COMPUTE_CLASS = CloudRiftCompute
+
+    def __init__(self, config: CloudRiftConfig):
+        self.config = config
+        self._compute = CloudRiftCompute(self.config)
+
+    def compute(self) -> CloudRiftCompute:
+        return self._compute

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

@@ -0,0 +1,138 @@
+from typing import Dict, List, Optional
+
+from dstack._internal.core.backends.base.backend import Compute
+from dstack._internal.core.backends.base.compute import (
+    ComputeWithCreateInstanceSupport,
+    get_shim_commands,
+)
+from dstack._internal.core.backends.base.offers import get_catalog_offers
+from dstack._internal.core.backends.cloudrift.api_client import RiftClient
+from dstack._internal.core.backends.cloudrift.models import CloudRiftConfig
+from dstack._internal.core.errors import ComputeError
+from dstack._internal.core.models.backends.base import BackendType
+from dstack._internal.core.models.instances import (
+    InstanceAvailability,
+    InstanceConfiguration,
+    InstanceOffer,
+    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__)
+
+
+class CloudRiftCompute(
+    ComputeWithCreateInstanceSupport,
+    Compute,
+):
+    def __init__(self, config: CloudRiftConfig):
+        super().__init__()
+        self.config = config
+        self.client = RiftClient(self.config.creds.api_key)
+
+    def get_offers(
+        self, requirements: Optional[Requirements] = None
+    ) -> List[InstanceOfferWithAvailability]:
+        offers = get_catalog_offers(
+            backend=BackendType.CLOUDRIFT,
+            locations=self.config.regions or None,
+            requirements=requirements,
+        )
+
+        offers_with_availabilities = self._get_offers_with_availability(offers)
+        return offers_with_availabilities
+
+    def _get_offers_with_availability(
+        self, offers: List[InstanceOffer]
+    ) -> List[InstanceOfferWithAvailability]:
+        instance_types_with_availabilities: List[Dict] = self.client.get_instance_types()
+
+        region_availabilities = {}
+        for instance_type in instance_types_with_availabilities:
+            for variant in instance_type["variants"]:
+                for dc, count in variant["available_nodes_per_dc"].items():
+                    if count > 0:
+                        key = (variant["name"], dc)
+                        region_availabilities[key] = InstanceAvailability.AVAILABLE
+
+        availability_offers = []
+        for offer in offers:
+            key = (offer.instance.name, offer.region)
+            availability = region_availabilities.get(key, InstanceAvailability.NOT_AVAILABLE)
+            availability_offers.append(
+                InstanceOfferWithAvailability(**offer.dict(), availability=availability)
+            )
+
+        return availability_offers
+
+    def create_instance(
+        self,
+        instance_offer: InstanceOfferWithAvailability,
+        instance_config: InstanceConfiguration,
+        placement_group: Optional[PlacementGroup],
+    ) -> JobProvisioningData:
+        commands = get_shim_commands(authorized_keys=instance_config.get_public_keys())
+        startup_script = " ".join([" && ".join(commands)])
+        logger.debug(
+            f"Creating instance for offer {instance_offer.instance.name} in region {instance_offer.region} with commands: {startup_script}"
+        )
+
+        instance_ids = self.client.deploy_instance(
+            instance_type=instance_offer.instance.name,
+            region=instance_offer.region,
+            ssh_keys=instance_config.get_public_keys(),
+            cmd=startup_script,
+        )
+
+        if len(instance_ids) == 0:
+            raise ComputeError(
+                f"Failed to create instance for offer {instance_offer.instance.name} in region {instance_offer.region}."
+            )
+
+        return JobProvisioningData(
+            backend=instance_offer.backend,
+            instance_type=instance_offer.instance,
+            instance_id=instance_ids[0],
+            hostname=None,
+            internal_ip=None,
+            region=instance_offer.region,
+            price=instance_offer.price,
+            username="riftuser",
+            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,
+    ):
+        instance_info = self.client.get_instance_by_id(provisioning_data.instance_id)
+
+        if not instance_info:
+            return
+
+        instance_mode = instance_info.get("node_mode", "")
+
+        if not instance_mode or instance_mode != "VirtualMachine":
+            return
+
+        vms = instance_info.get("virtual_machines", [])
+        if len(vms) == 0:
+            return
+
+        vm_ready = vms[0].get("ready", False)
+        if vm_ready:
+            provisioning_data.hostname = instance_info.get("host_address", None)
+
+    def terminate_instance(
+        self, instance_id: str, region: str, backend_data: Optional[str] = None
+    ):
+        terminated = self.client.terminate_instance(instance_id=instance_id)
+        if not terminated:
+            raise ComputeError(f"Failed to terminate instance {instance_id} in region {region}.")