dstack 0.19.4rc3__py3-none-any.whl → 0.19.6rc1__py3-none-any.whl

dstack/_internal/cli/commands/attach.py

@@ -69,6 +69,7 @@ class AttachCommand(APIBaseCommand):
         run = self.api.runs.get(args.run_name)
         if run is None:
             raise CLIError(f"Run {args.run_name} not found")
+        exit_code = 0
         try:
             attached = run.attach(
                 ssh_identity_file=args.ssh_identity_file,
@@ -90,35 +91,36 @@ class AttachCommand(APIBaseCommand):
                     replica_num=args.replica,
                     job_num=args.job,
                 )
-                try:
-                    for log in logs:
-                        sys.stdout.buffer.write(log)
-                        sys.stdout.buffer.flush()
-                except KeyboardInterrupt:
-                    pass
+                for log in logs:
+                    sys.stdout.buffer.write(log)
+                    sys.stdout.buffer.flush()
+                _print_finished_message_when_available(run)
+                exit_code = get_run_exit_code(run)
             else:
-                try:
-                    while True:
-                        time.sleep(10)
-                except KeyboardInterrupt:
-                    pass
+                while True:
+                    time.sleep(10)
+        except KeyboardInterrupt:
+            console.print("\nDetached")
         finally:
             run.detach()
         # TODO: Handle run resubmissions similar to dstack apply
+        exit(exit_code)
 
-        # After reading the logs, the run may not be marked as finished immediately.
-        # Give the run some time to transition to a finished state before exiting.
-        for _ in range(30):
-            run.refresh()
-            if run.status.is_finished():
-                print_finished_message(run)
-                exit(get_run_exit_code(run))
-            time.sleep(1)
+
+def _print_finished_message_when_available(run: Run) -> None:
+    # After reading the logs, the run may not be marked as finished immediately.
+    # Give the run some time to transition to a finished state before exiting.
+    for _ in range(30):
+        run.refresh()
+        if run.status.is_finished():
+            print_finished_message(run)
+            break
+        time.sleep(1)
+    else:
         console.print(
             "[error]Lost run connection. Timed out waiting for run final status."
             " Check `dstack ps` to see if it's done or failed."
         )
-        exit(1)
 
 
 _IGNORED_PORTS = [DSTACK_RUNNER_HTTP_PORT]

dstack/_internal/cli/commands/offer.py

@@ -0,0 +1,116 @@
+import argparse
+import contextlib
+import json
+from pathlib import Path
+
+from dstack._internal.cli.commands import APIBaseCommand
+from dstack._internal.cli.services.configurators.run import (
+    BaseRunConfigurator,
+)
+from dstack._internal.cli.utils.common import console
+from dstack._internal.cli.utils.run import print_run_plan
+from dstack._internal.core.models.configurations import (
+    ApplyConfigurationType,
+    TaskConfiguration,
+)
+from dstack._internal.core.models.runs import RunSpec
+from dstack.api.utils import load_profile
+
+
+class OfferConfigurator(BaseRunConfigurator):
+    # TODO: The command currently uses `BaseRunConfigurator` to register arguments.
+    #   This includes --env, --retry-policy, and other arguments that are unnecessary for this command.
+    #   Eventually, we should introduce a base `OfferConfigurator` that doesn't include those arguments—
+    #   `BaseRunConfigurator` will inherit from `OfferConfigurator`.
+    #
+    #   Additionally, it should have its own type: `ApplyConfigurationType.OFFER`.
+    TYPE = ApplyConfigurationType.TASK
+
+    @classmethod
+    def register_args(
+        cls,
+        parser: argparse.ArgumentParser,
+    ):
+        super().register_args(parser, default_max_offers=50)
+
+
+# TODO: Support aggregated offers
+# TODO: Add tests
+class OfferCommand(APIBaseCommand):
+    NAME = "offer"
+    DESCRIPTION = "List offers"
+
+    def _register(self):
+        super()._register()
+        self._parser.add_argument(
+            "--format",
+            choices=["plain", "json"],
+            default="plain",
+            help="Output format (default: plain)",
+        )
+        self._parser.add_argument(
+            "--json",
+            action="store_const",
+            const="json",
+            dest="format",
+            help="Output in JSON format (equivalent to --format json)",
+        )
+        OfferConfigurator.register_args(self._parser)
+
+    def _command(self, args: argparse.Namespace):
+        super()._command(args)
+        conf = TaskConfiguration(commands=[":"])
+
+        configurator = OfferConfigurator(api_client=self.api)
+        configurator.apply_args(conf, args, [])
+        profile = load_profile(Path.cwd(), profile_name=args.profile)
+
+        run_spec = RunSpec(
+            configuration=conf,
+            ssh_key_pub="(dummy)",
+            profile=profile,
+        )
+        if args.format == "plain":
+            status = console.status("Getting offers...")
+        else:
+            status = contextlib.nullcontext()
+        with status:
+            run_plan = self.api.client.runs.get_plan(
+                self.api.project,
+                run_spec,
+                max_offers=args.max_offers,
+            )
+
+        job_plan = run_plan.job_plans[0]
+
+        if args.format == "json":
+            output = {
+                "project": run_plan.project_name,
+                "user": run_plan.user,
+                "resources": job_plan.job_spec.requirements.resources.dict(),
+                "max_price": (job_plan.job_spec.requirements.max_price),
+                "spot": run_spec.configuration.spot_policy,
+                "reservation": run_plan.run_spec.configuration.reservation,
+                "offers": [],
+                "total_offers": job_plan.total_offers,
+            }
+
+            for offer in job_plan.offers:
+                output["offers"].append(
+                    {
+                        "backend": (
+                            "ssh" if offer.backend.value == "remote" else offer.backend.value
+                        ),
+                        "region": offer.region,
+                        "instance_type": offer.instance.name,
+                        "resources": offer.instance.resources.dict(),
+                        "spot": offer.instance.resources.spot,
+                        "price": float(offer.price),
+                        "availability": offer.availability.value,
+                    }
+                )
+
+            print(json.dumps(output, indent=2))
+            return
+        else:
+            print_run_plan(run_plan, include_run_properties=False)

dstack/_internal/cli/main.py

@@ -14,6 +14,7 @@ from dstack._internal.cli.commands.gateway import GatewayCommand
 from dstack._internal.cli.commands.init import InitCommand
 from dstack._internal.cli.commands.logs import LogsCommand
 from dstack._internal.cli.commands.metrics import MetricsCommand
+from dstack._internal.cli.commands.offer import OfferCommand
 from dstack._internal.cli.commands.ps import PsCommand
 from dstack._internal.cli.commands.server import ServerCommand
 from dstack._internal.cli.commands.stats import StatsCommand
@@ -65,6 +66,7 @@ def main():
     FleetCommand.register(subparsers)
     GatewayCommand.register(subparsers)
     InitCommand.register(subparsers)
+    OfferCommand.register(subparsers)
     LogsCommand.register(subparsers)
     MetricsCommand.register(subparsers)
     PsCommand.register(subparsers)

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

@@ -5,7 +5,6 @@ from typing import List, Optional, Union, cast
 
 from dstack._internal.cli.services.args import env_var
 from dstack._internal.core.errors import ConfigurationError
-from dstack._internal.core.models.common import is_core_model_instance
 from dstack._internal.core.models.configurations import (
     AnyApplyConfiguration,
     ApplyConfigurationType,
@@ -100,7 +99,7 @@ class ApplyEnvVarsConfiguratorMixin:
         for k, v in cast(List[EnvVarTuple], configurator_args.env_vars):
             env[k] = v
         for k, v in env.items():
-            if is_core_model_instance(v, EnvSentinel):
+            if isinstance(v, EnvSentinel):
                 try:
                     env[k] = v.from_env(os.environ)
                 except ValueError as e:

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

@@ -17,7 +17,13 @@ from dstack._internal.cli.utils.common import (
 )
 from dstack._internal.cli.utils.fleet import get_fleets_table
 from dstack._internal.cli.utils.rich import MultiItemStatus
-from dstack._internal.core.errors import ConfigurationError, ResourceNotExistsError
+from dstack._internal.core.errors import (
+    CLIError,
+    ConfigurationError,
+    ResourceNotExistsError,
+    ServerClientError,
+    URLNotFoundError,
+)
 from dstack._internal.core.models.configurations import ApplyConfigurationType
 from dstack._internal.core.models.fleets import (
     Fleet,
@@ -31,6 +37,7 @@ from dstack._internal.core.models.repos.base import Repo
 from dstack._internal.utils.common import local_time
 from dstack._internal.utils.logging import get_logger
 from dstack._internal.utils.ssh import convert_ssh_key_to_pem, generate_public_key, pkey_from_str
+from dstack.api._public import Client
 from dstack.api.utils import load_profile
 
 logger = get_logger(__name__)
@@ -109,11 +116,11 @@ class FleetConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
                     else:
                         time.sleep(1)
 
-        with console.status("Creating fleet..."):
-            fleet = self.api.client.fleets.create(
-                project_name=self.api.project,
-                spec=spec,
-            )
+        try:
+            with console.status("Applying plan..."):
+                fleet = _apply_plan(self.api, plan)
+        except ServerClientError as e:
+            raise CLIError(e.msg)
         if command_args.detach:
             console.print("Fleet configuration submitted. Exiting...")
             return
@@ -239,32 +246,34 @@ def _print_plan_header(plan: FleetPlan):
     def th(s: str) -> str:
         return f"[bold]{s}[/bold]"
 
+    spec = plan.get_effective_spec()
+
     configuration_table = Table(box=None, show_header=False)
     configuration_table.add_column(no_wrap=True)  # key
     configuration_table.add_column()  # value
 
     configuration_table.add_row(th("Project"), plan.project_name)
     configuration_table.add_row(th("User"), plan.user)
-    configuration_table.add_row(th("Configuration"), plan.spec.configuration_path or "?")
-    configuration_table.add_row(th("Type"), plan.spec.configuration.type)
+    configuration_table.add_row(th("Configuration"), spec.configuration_path or "?")
+    configuration_table.add_row(th("Type"), spec.configuration.type)
 
     fleet_type = "cloud"
-    nodes = plan.spec.configuration.nodes or "-"
-    placement = plan.spec.configuration.placement or InstanceGroupPlacement.ANY
-    reservation = plan.spec.configuration.reservation
+    nodes = spec.configuration.nodes or "-"
+    placement = spec.configuration.placement or InstanceGroupPlacement.ANY
+    reservation = spec.configuration.reservation
     backends = None
-    if plan.spec.configuration.backends is not None:
-        backends = ", ".join(b.value for b in plan.spec.configuration.backends)
+    if spec.configuration.backends is not None:
+        backends = ", ".join(b.value for b in spec.configuration.backends)
     regions = None
-    if plan.spec.configuration.regions is not None:
-        regions = ", ".join(plan.spec.configuration.regions)
+    if spec.configuration.regions is not None:
+        regions = ", ".join(spec.configuration.regions)
     resources = None
-    if plan.spec.configuration.resources is not None:
-        resources = plan.spec.configuration.resources.pretty_format()
-    spot_policy = plan.spec.merged_profile.spot_policy
-    if plan.spec.configuration.ssh_config is not None:
+    if spec.configuration.resources is not None:
+        resources = spec.configuration.resources.pretty_format()
+    spot_policy = spec.merged_profile.spot_policy
+    if spec.configuration.ssh_config is not None:
         fleet_type = "ssh"
-        nodes = len(plan.spec.configuration.ssh_config.hosts)
+        nodes = len(spec.configuration.ssh_config.hosts)
         resources = None
         spot_policy = None
 
@@ -350,3 +359,17 @@ def _failed_provisioning(fleet: Fleet) -> bool:
         if instance.status == InstanceStatus.TERMINATED:
             return True
     return False
+
+
+def _apply_plan(api: Client, plan: FleetPlan) -> Fleet:
+    try:
+        return api.client.fleets.apply_plan(
+            project_name=api.project,
+            plan=plan,
+        )
+    except URLNotFoundError:
+        # TODO: Remove in 0.20
+        return api.client.fleets.create(
+            project_name=api.project,
+            spec=plan.spec,
+        )

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

@@ -92,7 +92,7 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
                 profile=profile,
             )
 
-        print_run_plan(run_plan, offers_limit=configurator_args.max_offers)
+        print_run_plan(run_plan, max_offers=configurator_args.max_offers)
 
         confirm_message = "Submit a new run?"
         stop_run_name = None
@@ -274,7 +274,7 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
         console.print(f"Run [code]{conf.name}[/] deleted")
 
     @classmethod
-    def register_args(cls, parser: argparse.ArgumentParser):
+    def register_args(cls, parser: argparse.ArgumentParser, default_max_offers: int = 3):
         configuration_group = parser.add_argument_group(f"{cls.TYPE.value} Options")
         configuration_group.add_argument(
             "-n",
@@ -286,7 +286,7 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
             "--max-offers",
             help="Number of offers to show in the run plan",
             type=int,
-            default=3,
+            default=default_max_offers,
         )
         cls.register_env_args(configuration_group)
         configuration_group.add_argument(

dstack/_internal/cli/utils/run.py

@@ -1,10 +1,9 @@
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
 
 from rich.markup import escape
 from rich.table import Table
 
 from dstack._internal.cli.utils.common import NO_OFFERS_WARNING, add_row_from_dict, console
-from dstack._internal.core.models.common import is_core_model_instance
 from dstack._internal.core.models.configurations import DevEnvironmentConfiguration
 from dstack._internal.core.models.instances import InstanceAvailability
 from dstack._internal.core.models.profiles import (
@@ -25,7 +24,10 @@ from dstack._internal.utils.common import (
 from dstack.api import Run
 
 
-def print_run_plan(run_plan: RunPlan, offers_limit: int = 3):
+def print_run_plan(
+    run_plan: RunPlan, max_offers: Optional[int] = None, include_run_properties: bool = True
+):
+    run_spec = run_plan.get_effective_run_spec()
     job_plan = run_plan.job_plans[0]
 
     props = Table(box=None, show_header=False)
@@ -40,29 +42,30 @@ def print_run_plan(run_plan: RunPlan, offers_limit: int = 3):
         if job_plan.job_spec.max_duration
         else "-"
     )
-    inactivity_duration = None
-    if is_core_model_instance(run_plan.run_spec.configuration, DevEnvironmentConfiguration):
-        inactivity_duration = "-"
-        if isinstance(run_plan.run_spec.configuration.inactivity_duration, int):
-            inactivity_duration = format_pretty_duration(
-                run_plan.run_spec.configuration.inactivity_duration
-            )
-    if job_plan.job_spec.retry is None:
-        retry = "-"
-    else:
-        retry = escape(job_plan.job_spec.retry.pretty_format())
-
-    profile = run_plan.run_spec.merged_profile
-    creation_policy = profile.creation_policy
-    # FIXME: This assumes the default idle_duration is the same for client and server.
-    # If the server changes idle_duration, old clients will see incorrect value.
-    termination_policy, termination_idle_time = get_termination(
-        profile, DEFAULT_RUN_TERMINATION_IDLE_TIME
-    )
-    if termination_policy == TerminationPolicy.DONT_DESTROY:
-        idle_duration = "-"
-    else:
-        idle_duration = format_pretty_duration(termination_idle_time)
+    if include_run_properties:
+        inactivity_duration = None
+        if isinstance(run_spec.configuration, DevEnvironmentConfiguration):
+            inactivity_duration = "-"
+            if isinstance(run_spec.configuration.inactivity_duration, int):
+                inactivity_duration = format_pretty_duration(
+                    run_spec.configuration.inactivity_duration
+                )
+        if job_plan.job_spec.retry is None:
+            retry = "-"
+        else:
+            retry = escape(job_plan.job_spec.retry.pretty_format())
+
+        profile = run_spec.merged_profile
+        creation_policy = profile.creation_policy
+        # FIXME: This assumes the default idle_duration is the same for client and server.
+        # If the server changes idle_duration, old clients will see incorrect value.
+        termination_policy, termination_idle_time = get_termination(
+            profile, DEFAULT_RUN_TERMINATION_IDLE_TIME
+        )
+        if termination_policy == TerminationPolicy.DONT_DESTROY:
+            idle_duration = "-"
+        else:
+            idle_duration = format_pretty_duration(termination_idle_time)
 
     if req.spot is None:
         spot_policy = "auto"
@@ -76,30 +79,32 @@ def print_run_plan(run_plan: RunPlan, offers_limit: int = 3):
 
     props.add_row(th("Project"), run_plan.project_name)
     props.add_row(th("User"), run_plan.user)
-    props.add_row(th("Configuration"), run_plan.run_spec.configuration_path)
-    props.add_row(th("Type"), run_plan.run_spec.configuration.type)
+    if include_run_properties:
+        props.add_row(th("Configuration"), run_spec.configuration_path)
+        props.add_row(th("Type"), run_spec.configuration.type)
     props.add_row(th("Resources"), pretty_req)
-    props.add_row(th("Max price"), max_price)
-    props.add_row(th("Max duration"), max_duration)
-    if inactivity_duration is not None:  # None means n/a
-        props.add_row(th("Inactivity duration"), inactivity_duration)
     props.add_row(th("Spot policy"), spot_policy)
-    props.add_row(th("Retry policy"), retry)
-    props.add_row(th("Creation policy"), creation_policy)
-    props.add_row(th("Idle duration"), idle_duration)
-    props.add_row(th("Reservation"), run_plan.run_spec.configuration.reservation or "-")
+    props.add_row(th("Max price"), max_price)
+    if include_run_properties:
+        props.add_row(th("Retry policy"), retry)
+        props.add_row(th("Creation policy"), creation_policy)
+        props.add_row(th("Idle duration"), idle_duration)
+        props.add_row(th("Max duration"), max_duration)
+        if inactivity_duration is not None:  # None means n/a
+            props.add_row(th("Inactivity duration"), inactivity_duration)
+    props.add_row(th("Reservation"), run_spec.configuration.reservation or "-")
 
     offers = Table(box=None)
     offers.add_column("#")
     offers.add_column("BACKEND")
     offers.add_column("REGION")
-    offers.add_column("INSTANCE")
+    offers.add_column("INSTANCE TYPE")
     offers.add_column("RESOURCES")
     offers.add_column("SPOT")
     offers.add_column("PRICE")
     offers.add_column()
 
-    job_plan.offers = job_plan.offers[:offers_limit]
+    job_plan.offers = job_plan.offers[:max_offers] if max_offers else job_plan.offers
 
     for i, offer in enumerate(job_plan.offers, start=1):
         r = offer.instance.resources

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

@@ -4,7 +4,6 @@ from boto3.session import Session
 
 from dstack._internal.core.backends.aws.models import AnyAWSCreds, AWSAccessKeyCreds
 from dstack._internal.core.errors import BackendAuthError
-from dstack._internal.core.models.common import is_core_model_instance
 
 
 def authenticate(creds: AnyAWSCreds, region: str) -> Session:
@@ -14,7 +13,7 @@ def authenticate(creds: AnyAWSCreds, region: str) -> Session:
 
 
 def get_session(creds: AnyAWSCreds, region: str) -> Session:
-    if is_core_model_instance(creds, AWSAccessKeyCreds):
+    if isinstance(creds, AWSAccessKeyCreds):
         return boto3.session.Session(
             region_name=region,
             aws_access_key_id=creds.access_key,

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

@@ -28,7 +28,7 @@ from dstack._internal.core.backends.base.compute import (
 from dstack._internal.core.backends.base.offers import get_catalog_offers
 from dstack._internal.core.errors import ComputeError, NoCapacityError, PlacementGroupInUseError
 from dstack._internal.core.models.backends.base import BackendType
-from dstack._internal.core.models.common import CoreModel, is_core_model_instance
+from dstack._internal.core.models.common import CoreModel
 from dstack._internal.core.models.gateways import (
     GatewayComputeConfiguration,
     GatewayProvisioningData,
@@ -79,7 +79,7 @@ class AWSCompute(
     def __init__(self, config: AWSConfig):
         super().__init__()
         self.config = config
-        if is_core_model_instance(config.creds, AWSAccessKeyCreds):
+        if isinstance(config.creds, AWSAccessKeyCreds):
             self.session = boto3.Session(
                 aws_access_key_id=config.creds.access_key,
                 aws_secret_access_key=config.creds.secret_key,
@@ -169,14 +169,19 @@ class AWSCompute(
             raise NoCapacityError("No eligible availability zones")
 
         instance_name = generate_unique_instance_name(instance_config)
-        tags = {
+        base_tags = {
             "Name": instance_name,
             "owner": "dstack",
             "dstack_project": project_name,
             "dstack_name": instance_config.instance_name,
             "dstack_user": instance_config.user,
         }
-        tags = merge_tags(tags=tags, backend_tags=self.config.tags)
+        tags = merge_tags(
+            base_tags=base_tags,
+            backend_tags=self.config.tags,
+            resource_tags=instance_config.tags,
+        )
+        tags = aws_resources.filter_invalid_tags(tags)
 
         disk_size = round(instance_offer.instance.resources.disk.size_mib / 1024)
         max_efa_interfaces = _get_maximum_efa_interfaces(
@@ -326,15 +331,20 @@ class AWSCompute(
         ec2_client = self.session.client("ec2", region_name=configuration.region)
 
         instance_name = generate_unique_gateway_instance_name(configuration)
-        tags = {
+        base_tags = {
             "Name": instance_name,
             "owner": "dstack",
             "dstack_project": configuration.project_name,
             "dstack_name": configuration.instance_name,
         }
         if settings.DSTACK_VERSION is not None:
-            tags["dstack_version"] = settings.DSTACK_VERSION
-        tags = merge_tags(tags=tags, backend_tags=self.config.tags)
+            base_tags["dstack_version"] = settings.DSTACK_VERSION
+        tags = merge_tags(
+            base_tags=base_tags,
+            backend_tags=self.config.tags,
+            resource_tags=configuration.tags,
+        )
+        tags = aws_resources.filter_invalid_tags(tags)
         tags = aws_resources.make_tags(tags)
 
         vpc_id, subnets_ids = get_vpc_id_subnet_id_or_error(
@@ -522,14 +532,19 @@ class AWSCompute(
         ec2_client = self.session.client("ec2", region_name=volume.configuration.region)
 
         volume_name = generate_unique_volume_name(volume)
-        tags = {
+        base_tags = {
             "Name": volume_name,
             "owner": "dstack",
             "dstack_project": volume.project_name,
             "dstack_name": volume.name,
             "dstack_user": volume.user,
         }
-        tags = merge_tags(tags=tags, backend_tags=self.config.tags)
+        tags = merge_tags(
+            base_tags=base_tags,
+            backend_tags=self.config.tags,
+            resource_tags=volume.configuration.tags,
+        )
+        tags = aws_resources.filter_invalid_tags(tags)
 
         zones = aws_resources.get_availability_zones(
             ec2_client=ec2_client, region=volume.configuration.region

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

@@ -29,7 +29,6 @@ from dstack._internal.core.errors import (
 from dstack._internal.core.models.backends.base import (
     BackendType,
 )
-from dstack._internal.core.models.common import is_core_model_instance
 from dstack._internal.utils.logging import get_logger
 
 logger = get_logger(__name__)
@@ -58,12 +57,12 @@ class AWSConfigurator(Configurator):
     BACKEND_CLASS = AWSBackend
 
     def validate_config(self, config: AWSBackendConfigWithCreds, default_creds_enabled: bool):
-        if is_core_model_instance(config.creds, AWSDefaultCreds) and not default_creds_enabled:
+        if isinstance(config.creds, AWSDefaultCreds) and not default_creds_enabled:
             raise_invalid_credentials_error(fields=[["creds"]])
         try:
             session = auth.authenticate(creds=config.creds, region=MAIN_REGION)
         except Exception:
-            if is_core_model_instance(config.creds, AWSAccessKeyCreds):
+            if isinstance(config.creds, AWSAccessKeyCreds):
                 raise_invalid_credentials_error(
                     fields=[
                         ["creds", "access_key"],

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

@@ -448,6 +448,16 @@ def make_tags(tags: Dict[str, str]) -> List[Dict[str, str]]:
     return tags_list
 
 
+def filter_invalid_tags(tags: Dict[str, str]) -> Dict[str, str]:
+    filtered_tags = {}
+    for k, v in tags.items():
+        if not _is_valid_tag(k, v):
+            logger.warning("Skipping invalid tag '%s: %s'", k, v)
+            continue
+        filtered_tags[k] = v
+    return filtered_tags
+
+
 def validate_tags(tags: Dict[str, str]):
     for k, v in tags.items():
         if not _is_valid_tag(k, v):

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

@@ -9,7 +9,6 @@ from dstack._internal.core.backends.azure.models import (
     AzureClientCreds,
 )
 from dstack._internal.core.errors import BackendAuthError
-from dstack._internal.core.models.common import is_core_model_instance
 
 AzureCredential = Union[ClientSecretCredential, DefaultAzureCredential]
 
@@ -21,7 +20,7 @@ def authenticate(creds: AnyAzureCreds) -> Tuple[AzureCredential, str]:
 
 
 def get_credential(creds: AnyAzureCreds) -> Tuple[AzureCredential, str]:
-    if is_core_model_instance(creds, AzureClientCreds):
+    if isinstance(creds, AzureClientCreds):
         credential = ClientSecretCredential(
             tenant_id=creds.tenant_id,
             client_id=creds.client_id,