dstack 0.19.6rc1__py3-none-any.whl → 0.19.8__py3-none-any.whl

dstack/_internal/server/background/tasks/process_fleets.py

@@ -1,15 +1,16 @@
-from sqlalchemy import select, update
+from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import joinedload
 
 from dstack._internal.core.models.fleets import FleetStatus
 from dstack._internal.server.db import get_session_ctx
-from dstack._internal.server.models import FleetModel, PlacementGroupModel
+from dstack._internal.server.models import FleetModel
 from dstack._internal.server.services.fleets import (
     is_fleet_empty,
     is_fleet_in_use,
 )
 from dstack._internal.server.services.locking import get_locker
+from dstack._internal.server.services.placement import schedule_fleet_placement_groups_deletion
 from dstack._internal.utils.common import get_current_datetime
 from dstack._internal.utils.logging import get_logger
 
@@ -68,16 +69,6 @@ async def _autodelete_fleet(session: AsyncSession, fleet_model: FleetModel):
     fleet_model.status = FleetStatus.TERMINATED
     fleet_model.deleted = True
     fleet_model.last_processed_at = get_current_datetime()
-    await _mark_placement_groups_as_ready_for_deletion(session=session, fleet_model=fleet_model)
+    await schedule_fleet_placement_groups_deletion(session=session, fleet_id=fleet_model.id)
     await session.commit()
     logger.info("Fleet %s deleted", fleet_model.name)
-
-
-async def _mark_placement_groups_as_ready_for_deletion(
-    session: AsyncSession, fleet_model: FleetModel
-):
-    await session.execute(
-        update(PlacementGroupModel)
-        .where(PlacementGroupModel.fleet_id == fleet_model.id)
-        .values(fleet_deleted=True)
-    )

dstack/_internal/server/background/tasks/process_instances.py

@@ -19,6 +19,8 @@ from dstack._internal.core.backends import (
 from dstack._internal.core.backends.base.compute import (
     ComputeWithCreateInstanceSupport,
     ComputeWithPlacementGroupSupport,
+    GoArchType,
+    generate_unique_placement_group_name,
     get_dstack_runner_binary_path,
     get_dstack_shim_binary_path,
     get_dstack_working_dir,
@@ -26,6 +28,7 @@ from dstack._internal.core.backends.base.compute import (
     get_shim_pre_start_commands,
 )
 from dstack._internal.core.backends.remote.provisioning import (
+    detect_cpu_arch,
     get_host_info,
     get_paramiko_connection,
     get_shim_healthcheck,
@@ -39,11 +42,16 @@ from dstack._internal.core.backends.remote.provisioning import (
 from dstack._internal.core.consts import DSTACK_SHIM_HTTP_PORT
 
 # FIXME: ProvisioningError is a subclass of ComputeError and should not be used outside of Compute
-from dstack._internal.core.errors import BackendError, NotYetTerminated, ProvisioningError
+from dstack._internal.core.errors import (
+    BackendError,
+    NotYetTerminated,
+    ProvisioningError,
+)
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.fleets import InstanceGroupPlacement
 from dstack._internal.core.models.instances import (
     InstanceAvailability,
+    InstanceOffer,
     InstanceOfferWithAvailability,
     InstanceRuntime,
     InstanceStatus,
@@ -51,7 +59,6 @@ from dstack._internal.core.models.instances import (
     SSHKey,
 )
 from dstack._internal.core.models.placement import (
-    PlacementGroup,
     PlacementGroupConfiguration,
     PlacementStrategy,
 )
@@ -89,8 +96,9 @@ from dstack._internal.server.services.instances import (
 from dstack._internal.server.services.locking import get_locker
 from dstack._internal.server.services.offers import is_divisible_into_blocks
 from dstack._internal.server.services.placement import (
-    get_fleet_placement_groups,
+    get_fleet_placement_group_models,
     placement_group_model_to_placement_group,
+    schedule_fleet_placement_groups_deletion,
 )
 from dstack._internal.server.services.runner import client as runner_client
 from dstack._internal.server.services.runner.client import HealthStatus
@@ -264,7 +272,7 @@ async def _add_remote(instance: InstanceModel) -> None:
             )
             deploy_timeout = 20 * 60  # 20 minutes
             result = await asyncio.wait_for(future, timeout=deploy_timeout)
-            health, host_info = result
+            health, host_info, cpu_arch = result
         except (asyncio.TimeoutError, TimeoutError) as e:
             raise ProvisioningError(f"Deploy timeout: {e}") from e
         except Exception as e:
@@ -285,7 +293,7 @@ async def _add_remote(instance: InstanceModel) -> None:
         instance.last_retry_at = get_current_datetime()
         return
 
-    instance_type = host_info_to_instance_type(host_info)
+    instance_type = host_info_to_instance_type(host_info, cpu_arch)
     instance_network = None
     internal_ip = None
     try:
@@ -388,7 +396,7 @@ def _deploy_instance(
     pkeys: List[PKey],
     ssh_proxy_pkeys: Optional[list[PKey]],
     authorized_keys: List[str],
-) -> Tuple[HealthStatus, Dict[str, Any]]:
+) -> Tuple[HealthStatus, Dict[str, Any], GoArchType]:
     with get_paramiko_connection(
         remote_details.ssh_user,
         remote_details.host,
@@ -399,13 +407,16 @@ def _deploy_instance(
     ) as client:
         logger.info(f"Connected to {remote_details.ssh_user} {remote_details.host}")
 
+        arch = detect_cpu_arch(client)
+        logger.info("%s: CPU arch is %s", remote_details.host, arch)
+
         # Execute pre start commands
-        shim_pre_start_commands = get_shim_pre_start_commands()
+        shim_pre_start_commands = get_shim_pre_start_commands(arch=arch)
         run_pre_start_commands(client, shim_pre_start_commands, authorized_keys)
         logger.debug("The script for installing dstack has been executed")
 
         # Upload envs
-        shim_envs = get_shim_env(authorized_keys)
+        shim_envs = get_shim_env(authorized_keys, arch=arch)
         try:
             fleet_configuration_envs = remote_details.env.as_dict()
         except ValueError as e:
@@ -440,7 +451,7 @@ def _deploy_instance(
             raise ProvisioningError("Cannot read HealthcheckResponse") from e
         health = runner_client.health_response_to_health_status(health_response)
 
-        return health, host_info
+        return health, host_info, arch
 
 
 async def _create_instance(session: AsyncSession, instance: InstanceModel) -> None:
@@ -509,11 +520,39 @@ async def _create_instance(session: AsyncSession, instance: InstanceModel) -> No
             )
             return
 
+    placement_group_models = []
+    placement_group_model = None
+    if instance.fleet_id:
+        placement_group_models = await get_fleet_placement_group_models(
+            session=session,
+            fleet_id=instance.fleet_id,
+        )
+        # The placement group is determined when provisioning the master instance
+        # and used for all other instances in the fleet.
+        if not _is_fleet_master_instance(instance):
+            if placement_group_models:
+                placement_group_model = placement_group_models[0]
+            if len(placement_group_models) > 1:
+                logger.error(
+                    (
+                        "Expected 0 or 1 placement groups associated with fleet %s, found %s."
+                        " An incorrect placement group might have been selected for instance %s"
+                    ),
+                    instance.fleet_id,
+                    len(placement_group_models),
+                    instance.name,
+                )
+
     offers = await get_create_instance_offers(
         project=instance.project,
         profile=profile,
         requirements=requirements,
         fleet_model=instance.fleet,
+        placement_group=(
+            placement_group_model_to_placement_group(placement_group_model)
+            if placement_group_model
+            else None
+        ),
         blocks="auto" if instance.total_blocks is None else instance.total_blocks,
         exclude_not_available=True,
     )
@@ -527,12 +566,6 @@ async def _create_instance(session: AsyncSession, instance: InstanceModel) -> No
         )
         return
 
-    placement_groups = []
-    if instance.fleet_id:
-        placement_groups = await get_fleet_placement_groups(
-            session=session, fleet_id=instance.fleet_id
-        )
-
     # Limit number of offers tried to prevent long-running processing
     # in case all offers fail.
     for backend, instance_offer in offers[: server_settings.MAX_OFFERS_TRIED]:
@@ -542,25 +575,28 @@ async def _create_instance(session: AsyncSession, instance: InstanceModel) -> No
         assert isinstance(compute, ComputeWithCreateInstanceSupport)
         instance_offer = _get_instance_offer_for_instance(instance_offer, instance)
         if (
-            instance_offer.backend in BACKENDS_WITH_PLACEMENT_GROUPS_SUPPORT
+            _is_fleet_master_instance(instance)
+            and instance_offer.backend in BACKENDS_WITH_PLACEMENT_GROUPS_SUPPORT
             and instance.fleet
-            and instance_configuration.placement_group_name
+            and _is_cloud_cluster(instance.fleet)
         ):
             assert isinstance(compute, ComputeWithPlacementGroupSupport)
-            placement_group_model = _create_placement_group_if_does_not_exist(
-                session=session,
-                fleet_model=instance.fleet,
-                placement_groups=placement_groups,
-                name=instance_configuration.placement_group_name,
-                backend=instance_offer.backend,
-                region=instance_offer.region,
+            placement_group_model = _find_suitable_placement_group(
+                placement_groups=placement_group_models,
+                instance_offer=instance_offer,
+                compute=compute,
             )
-            if placement_group_model is not None:
-                placement_group = placement_group_model_to_placement_group(placement_group_model)
-                pgpd = await run_async(compute.create_placement_group, placement_group)
-                placement_group_model.provisioning_data = pgpd.json()
+            if placement_group_model is None:
+                placement_group_model = await _create_placement_group(
+                    fleet_model=instance.fleet,
+                    master_instance_offer=instance_offer,
+                    compute=compute,
+                )
+                if placement_group_model is None:  # error occurred
+                    continue
                 session.add(placement_group_model)
-                placement_groups.append(placement_group)
+                await session.flush()
+                placement_group_models.append(placement_group_model)
         logger.debug(
             "Trying %s in %s/%s for $%0.4f per hour",
             instance_offer.instance.name,
@@ -573,6 +609,11 @@ async def _create_instance(session: AsyncSession, instance: InstanceModel) -> No
                 compute.create_instance,
                 instance_offer,
                 instance_configuration,
+                (
+                    placement_group_model_to_placement_group(placement_group_model)
+                    if placement_group_model
+                    else None
+                ),
             )
         except BackendError as e:
             logger.warning(
@@ -612,22 +653,46 @@ async def _create_instance(session: AsyncSession, instance: InstanceModel) -> No
                 "instance_status": InstanceStatus.PROVISIONING.value,
             },
         )
+        if instance.fleet_id and _is_fleet_master_instance(instance):
+            # Clean up placement groups that did not end up being used
+            await schedule_fleet_placement_groups_deletion(
+                session=session,
+                fleet_id=instance.fleet_id,
+                except_placement_group_ids=(
+                    [placement_group_model.id] if placement_group_model is not None else []
+                ),
+            )
         return
 
     instance.last_retry_at = get_current_datetime()
 
     if not should_retry:
-        instance.status = InstanceStatus.TERMINATED
-        instance.termination_reason = "All offers failed" if offers else "No offers found"
-        logger.info(
-            "Terminated instance %s: %s",
-            instance.name,
-            instance.termination_reason,
-            extra={
-                "instance_name": instance.name,
-                "instance_status": InstanceStatus.TERMINATED.value,
-            },
-        )
+        _mark_terminated(instance, "All offers failed" if offers else "No offers found")
+        if (
+            instance.fleet
+            and _is_fleet_master_instance(instance)
+            and _is_cloud_cluster(instance.fleet)
+        ):
+            # Do not attempt to deploy other instances, as they won't determine the correct cluster
+            # backend, region, and placement group without a successfully deployed master instance
+            for sibling_instance in instance.fleet.instances:
+                if sibling_instance.id == instance.id:
+                    continue
+                _mark_terminated(sibling_instance, "Master instance failed to start")
+
+
+def _mark_terminated(instance: InstanceModel, termination_reason: str) -> None:
+    instance.status = InstanceStatus.TERMINATED
+    instance.termination_reason = termination_reason
+    logger.info(
+        "Terminated instance %s: %s",
+        instance.name,
+        instance.termination_reason,
+        extra={
+            "instance_name": instance.name,
+            "instance_status": InstanceStatus.TERMINATED.value,
+        },
+    )
 
 
 async def _check_instance(instance: InstanceModel) -> None:
@@ -906,12 +971,20 @@ def _need_to_wait_fleet_provisioning(instance: InstanceModel) -> bool:
     if instance.fleet is None:
         return False
     if (
-        instance.id == instance.fleet.instances[0].id
+        _is_fleet_master_instance(instance)
         or instance.fleet.instances[0].job_provisioning_data is not None
         or instance.fleet.instances[0].status == InstanceStatus.TERMINATED
     ):
         return False
-    fleet = fleet_model_to_fleet(instance.fleet)
+    return _is_cloud_cluster(instance.fleet)
+
+
+def _is_fleet_master_instance(instance: InstanceModel) -> bool:
+    return instance.fleet is not None and instance.id == instance.fleet.instances[0].id
+
+
+def _is_cloud_cluster(fleet_model: FleetModel) -> bool:
+    fleet = fleet_model_to_fleet(fleet_model)
     return (
         fleet.spec.configuration.placement == InstanceGroupPlacement.CLUSTER
         and fleet.spec.configuration.ssh_config is None
@@ -944,28 +1017,76 @@ def _get_instance_offer_for_instance(
     return instance_offer
 
 
-def _create_placement_group_if_does_not_exist(
-    session: AsyncSession,
-    fleet_model: FleetModel,
-    placement_groups: List[PlacementGroup],
-    name: str,
-    backend: BackendType,
-    region: str,
+def _find_suitable_placement_group(
+    placement_groups: List[PlacementGroupModel],
+    instance_offer: InstanceOffer,
+    compute: ComputeWithPlacementGroupSupport,
 ) -> Optional[PlacementGroupModel]:
     for pg in placement_groups:
-        if pg.configuration.backend == backend and pg.configuration.region == region:
-            return None
+        if compute.is_suitable_placement_group(
+            placement_group_model_to_placement_group(pg), instance_offer
+        ):
+            return pg
+    return None
+
+
+async def _create_placement_group(
+    fleet_model: FleetModel,
+    master_instance_offer: InstanceOffer,
+    compute: ComputeWithPlacementGroupSupport,
+) -> Optional[PlacementGroupModel]:
     placement_group_model = PlacementGroupModel(
-        name=name,
+        # TODO: generate the name in Compute.create_placement_group to allow
+        # backend-specific name length limits
+        name=generate_unique_placement_group_name(
+            project_name=fleet_model.project.name,
+            fleet_name=fleet_model.name,
+        ),
         project=fleet_model.project,
         fleet=fleet_model,
         configuration=PlacementGroupConfiguration(
-            backend=backend,
-            region=region,
+            backend=master_instance_offer.backend,
+            region=master_instance_offer.region,
             placement_strategy=PlacementStrategy.CLUSTER,
         ).json(),
     )
-    session.add(placement_group_model)
+    placement_group = placement_group_model_to_placement_group(placement_group_model)
+    logger.debug(
+        "Creating placement group %s in %s/%s",
+        placement_group.name,
+        placement_group.configuration.backend.value,
+        placement_group.configuration.region,
+    )
+    try:
+        pgpd = await run_async(
+            compute.create_placement_group,
+            placement_group_model_to_placement_group(placement_group_model),
+            master_instance_offer,
+        )
+    except BackendError as e:
+        logger.warning(
+            "Failed to create placement group %s in %s/%s: %r",
+            placement_group.name,
+            placement_group.configuration.backend.value,
+            placement_group.configuration.region,
+            e,
+        )
+        return None
+    except Exception:
+        logger.exception(
+            "Got exception when creating placement group %s in %s/%s",
+            placement_group.name,
+            placement_group.configuration.backend.value,
+            placement_group.configuration.region,
+        )
+        return None
+    logger.info(
+        "Created placement group %s in %s/%s",
+        placement_group.name,
+        placement_group.configuration.backend.value,
+        placement_group.configuration.region,
+    )
+    placement_group_model.provisioning_data = pgpd.json()
     return placement_group_model
 
 

dstack/_internal/server/background/tasks/process_placement_groups.py

@@ -66,7 +66,7 @@ async def _delete_placement_groups(
 
 
 async def _delete_placement_group(placement_group_model: PlacementGroupModel):
-    logger.info("Deleting placement group %s", placement_group_model.name)
+    logger.debug("Deleting placement group %s", placement_group_model.name)
     placement_group = placement_group_model_to_placement_group(placement_group_model)
     if placement_group.provisioning_data is None:
         logger.error(

dstack/_internal/server/background/tasks/process_prometheus_metrics.py

@@ -99,11 +99,14 @@ async def _collect_jobs_metrics(job_models: list[JobModel], collected_at: dateti
 
 
 async def _collect_job_metrics(job_model: JobModel) -> Optional[str]:
-    ssh_private_keys = get_instance_ssh_private_keys(get_or_error(job_model.instance))
     jpd = get_job_provisioning_data(job_model)
-    jrd = get_job_runtime_data(job_model)
     if jpd is None:
         return None
+    if not jpd.dockerized:
+        # Container-based backend, no shim
+        return None
+    ssh_private_keys = get_instance_ssh_private_keys(get_or_error(job_model.instance))
+    jrd = get_job_runtime_data(job_model)
     try:
         res = await run_async(
             _pull_job_metrics,

dstack/_internal/server/background/tasks/process_submitted_jobs.py

@@ -197,7 +197,7 @@ async def _process_submitted_job(session: AsyncSession, job_model: JobModel):
         pool_instances = list(res.unique().scalars().all())
         instances_ids = sorted([i.id for i in pool_instances])
         if get_db().dialect_name == "sqlite":
-            # Start new transaction to see commited changes after lock
+            # Start new transaction to see committed changes after lock
             await session.commit()
         async with get_locker().lock_ctx(InstanceModel.__tablename__, instances_ids):
             # If another job freed the instance but is still trying to detach volumes,

dstack/_internal/server/models.py

@@ -659,6 +659,7 @@ class PlacementGroupModel(BaseModel):
 
     fleet_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("fleets.id"))
     fleet: Mapped["FleetModel"] = relationship(foreign_keys=[fleet_id])
+    # TODO: rename `fleet_deleted` -> `to_be_deleted`
     fleet_deleted: Mapped[bool] = mapped_column(Boolean, default=False)
 
     created_at: Mapped[datetime] = mapped_column(NaiveDateTime, default=get_current_datetime)

dstack/_internal/server/routers/gateways.py

@@ -47,9 +47,10 @@ async def create_gateway(
     session: AsyncSession = Depends(get_session),
     user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectAdmin()),
 ) -> models.Gateway:
-    _, project = user_project
+    user, project = user_project
     return await gateways.create_gateway(
         session=session,
+        user=user,
         project=project,
         configuration=body.configuration,
     )

dstack/_internal/server/services/config.py

@@ -29,6 +29,7 @@ from dstack._internal.server.services.permissions import (
     DefaultPermissions,
     set_default_permissions,
 )
+from dstack._internal.server.services.plugins import load_plugins
 from dstack._internal.utils.logging import get_logger
 
 logger = get_logger(__name__)
@@ -38,7 +39,7 @@ logger = get_logger(__name__)
 # If a collection has nested collections, it will be assigned the block style. Otherwise it will have the flow style.
 #
 # We want mapping to always be displayed in block-style but lists without nested objects in flow-style.
-# So we define a custom representeter
+# So we define a custom representer.
 
 
 def seq_representer(dumper, sequence):
@@ -75,7 +76,10 @@ class ServerConfig(CoreModel):
     ] = None
     default_permissions: Annotated[
         Optional[DefaultPermissions], Field(description="The default user permissions")
-    ]
+    ] = None
+    plugins: Annotated[
+        Optional[List[str]], Field(description="The server-side plugins to enable")
+    ] = None
 
 
 class ServerConfigManager:
@@ -112,6 +116,7 @@ class ServerConfigManager:
             await self._apply_project_config(
                 session=session, owner=owner, project_config=project_config
             )
+        load_plugins(enabled_plugins=self.config.plugins or [])
 
     async def _apply_project_config(
         self,

dstack/_internal/server/services/fleets.py

@@ -1,5 +1,3 @@
-import random
-import string
 import uuid
 from datetime import datetime, timezone
 from typing import List, Literal, Optional, Tuple, Union, cast
@@ -33,6 +31,7 @@ from dstack._internal.core.models.instances import (
     SSHConnectionParams,
     SSHKey,
 )
+from dstack._internal.core.models.placement import PlacementGroup
 from dstack._internal.core.models.profiles import (
     Profile,
     SpotPolicy,
@@ -55,12 +54,14 @@ from dstack._internal.server.services.locking import (
     get_locker,
     string_to_lock_id,
 )
+from dstack._internal.server.services.plugins import apply_plugin_policies
 from dstack._internal.server.services.projects import (
     get_member,
     get_member_permissions,
     list_project_models,
     list_user_project_models,
 )
+from dstack._internal.server.services.resources import set_resources_defaults
 from dstack._internal.utils import random_names
 from dstack._internal.utils.logging import get_logger
 from dstack._internal.utils.ssh import pkey_from_str
@@ -234,7 +235,15 @@ async def get_plan(
     user: UserModel,
     spec: FleetSpec,
 ) -> FleetPlan:
+    # Spec must be copied by parsing to calculate merged_profile
     effective_spec = FleetSpec.parse_obj(spec.dict())
+    effective_spec = apply_plugin_policies(
+        user=user.name,
+        project=project.name,
+        spec=effective_spec,
+    )
+    effective_spec = FleetSpec.parse_obj(effective_spec.dict())
+    _validate_fleet_spec_and_set_defaults(spec)
     current_fleet: Optional[Fleet] = None
     current_fleet_id: Optional[uuid.UUID] = None
     if effective_spec.configuration.name is not None:
@@ -274,6 +283,7 @@ async def get_create_instance_offers(
     project: ProjectModel,
     profile: Profile,
     requirements: Requirements,
+    placement_group: Optional[PlacementGroup] = None,
     fleet_spec: Optional[FleetSpec] = None,
     fleet_model: Optional[FleetModel] = None,
     blocks: Union[int, Literal["auto"]] = 1,
@@ -299,6 +309,7 @@ async def get_create_instance_offers(
         exclude_not_available=exclude_not_available,
         multinode=multinode,
         master_job_provisioning_data=master_job_provisioning_data,
+        placement_group=placement_group,
         blocks=blocks,
     )
     offers = [
@@ -330,7 +341,14 @@ async def create_fleet(
     user: UserModel,
     spec: FleetSpec,
 ) -> Fleet:
-    _validate_fleet_spec(spec)
+    # Spec must be copied by parsing to calculate merged_profile
+    spec = apply_plugin_policies(
+        user=user.name,
+        project=project.name,
+        spec=spec,
+    )
+    spec = FleetSpec.parse_obj(spec.dict())
+    _validate_fleet_spec_and_set_defaults(spec)
 
     if spec.configuration.ssh_config is not None:
         _check_can_manage_ssh_fleets(user=user, project=project)
@@ -378,17 +396,12 @@ async def create_fleet(
                 )
                 fleet_model.instances.append(instances_model)
         else:
-            placement_group_name = _get_placement_group_name(
-                project=project,
-                fleet_spec=spec,
-            )
             for i in range(_get_fleet_nodes_to_provision(spec)):
                 instance_model = await create_fleet_instance_model(
                     session=session,
                     project=project,
                     user=user,
                     spec=spec,
-                    placement_group_name=placement_group_name,
                     reservation=spec.configuration.reservation,
                     instance_num=i,
                 )
@@ -402,7 +415,6 @@ async def create_fleet_instance_model(
     project: ProjectModel,
     user: UserModel,
     spec: FleetSpec,
-    placement_group_name: Optional[str],
     reservation: Optional[str],
     instance_num: int,
 ) -> InstanceModel:
@@ -416,7 +428,6 @@ async def create_fleet_instance_model(
         requirements=requirements,
         instance_name=f"{spec.configuration.name}-{instance_num}",
         instance_num=instance_num,
-        placement_group_name=placement_group_name,
         reservation=reservation,
         blocks=spec.configuration.blocks,
         tags=spec.configuration.tags,
@@ -637,7 +648,7 @@ def _remove_fleet_spec_sensitive_info(spec: FleetSpec):
                 host.ssh_key = None
 
 
-def _validate_fleet_spec(spec: FleetSpec):
+def _validate_fleet_spec_and_set_defaults(spec: FleetSpec):
     if spec.configuration.name is not None:
         validate_dstack_resource_name(spec.configuration.name)
     if spec.configuration.ssh_config is None and spec.configuration.nodes is None:
@@ -650,6 +661,8 @@ def _validate_fleet_spec(spec: FleetSpec):
             if isinstance(host, SSHHostParams) and host.ssh_key is not None:
                 _validate_ssh_key(host.ssh_key)
         _validate_internal_ips(spec.configuration.ssh_config)
+    if spec.configuration.resources is not None:
+        set_resources_defaults(spec.configuration.resources)
 
 
 def _validate_all_ssh_params_specified(ssh_config: SSHParams):
@@ -720,18 +733,3 @@ def _get_fleet_requirements(fleet_spec: FleetSpec) -> Requirements:
         reservation=fleet_spec.configuration.reservation,
     )
     return requirements
-
-
-def _get_placement_group_name(
-    project: ProjectModel,
-    fleet_spec: FleetSpec,
-) -> Optional[str]:
-    if fleet_spec.configuration.placement != InstanceGroupPlacement.CLUSTER:
-        return None
-    # A random suffix to avoid clashing with to-be-deleted placement groups left by old fleets
-    suffix = _generate_random_placement_group_suffix()
-    return f"{project.name}-{fleet_spec.configuration.name}-{suffix}-pg"
-
-
-def _generate_random_placement_group_suffix(length: int = 8) -> str:
-    return "".join(random.choice(string.ascii_lowercase + string.digits) for _ in range(length))