anyscale 0.5.122__tar.gz → 0.5.123__tar.gz

{anyscale-0.5.122/anyscale.egg-info → anyscale-0.5.123}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anyscale
-Version: 0.5.122
+Version: 0.5.123
 Summary: Command Line Interface for Anyscale
 Home-page: UNKNOWN
 Author: Anyscale Inc.

{anyscale-0.5.122 → anyscale-0.5.123}/anyscale/commands/cloud_commands.py

@@ -101,6 +101,13 @@ def cloud_set_default(
     required=False,
     type=str,
 )
+@click.option(
+    "--functional-verify",
+    help="Verify the cloud is functional. This will check that the cloud can launch workspace/service.",
+    required=False,
+    is_flag=False,
+    flag_value="workspace",
+)
 @click.option(
     "--anyscale-managed",
     is_flag=True,
@@ -119,6 +126,7 @@ def setup_cloud(  # noqa: PLR0913
     region: str,
     name: str,
     project_id: str,
+    functional_verify: Optional[str],
     anyscale_managed: bool,  # noqa: ARG001
     use_legacy_stack: bool,
 ) -> None:
@@ -133,6 +141,7 @@ def setup_cloud(  # noqa: PLR0913
             provider=provider,
             region=region,
             name=name,
+            functional_verify=functional_verify,
             cluster_management_stack_version=cluster_management_stack_version,
         )
     elif provider == "gcp":
@@ -143,6 +152,7 @@ def setup_cloud(  # noqa: PLR0913
             region=region,
             name=name,
             project_id=project_id,
+            functional_verify=functional_verify,
             cluster_management_stack_version=cluster_management_stack_version,
         )
 
@@ -402,6 +412,13 @@ def cloud_secrets(
     hidden=True,
     help="Whether to use the legacy stack.",
 )
+@click.option(
+    "--functional-verify",
+    help="Verify the cloud is functional. This will check that the cloud can launch workspace/service.",
+    required=False,
+    is_flag=False,
+    flag_value="workspace",
+)
 @click.option(
     "--yes", "-y", is_flag=True, default=False, help="Skip asking for confirmation."
 )
@@ -426,6 +443,7 @@ def register_cloud(  # noqa: PLR0913
     provider_name: str,
     firewall_policy_names: str,
     cloud_storage_bucket_name: str,
+    functional_verify: Optional[str],
     private_network: bool,
     use_legacy_stack: bool,
     yes: bool,
@@ -457,6 +475,7 @@ def register_cloud(  # noqa: PLR0913
             instance_iam_role_id=instance_iam_role_id,
             security_group_ids=security_group_ids.split(","),
             s3_bucket_id=s3_bucket_id,
+            functional_verify=functional_verify,
             private_network=private_network,
             cluster_management_stack_version=ClusterManagementStackVersions.V1
             if use_legacy_stack
@@ -514,6 +533,7 @@ def register_cloud(  # noqa: PLR0913
             provider_id=provider_name,
             firewall_policy_names=firewall_policy_names.split(","),
             cloud_storage_bucket_name=cloud_storage_bucket_name,
+            functional_verify=functional_verify,
             private_network=private_network,
             cluster_management_stack_version=ClusterManagementStackVersions.V1
             if use_legacy_stack
@@ -535,6 +555,13 @@ def register_cloud(  # noqa: PLR0913
     help="Verify cloud by cloud id, alternative to cloud name.",
     required=False,
 )
+@click.option(
+    "--functional-verify",
+    help="Verify the cloud is functional. This will check that the cloud can launch workspace/service.",
+    required=False,
+    is_flag=False,
+    flag_value="workspace",
+)
 @click.option(
     "--strict",
     is_flag=True,
@@ -545,6 +572,7 @@ def cloud_verify(
     cloud_name: Optional[str],
     name: Optional[str],
     cloud_id: Optional[str],
+    functional_verify: Optional[str],
     strict: bool = False,
 ) -> bool:
     if cloud_name and name and cloud_name != name:
@@ -554,5 +582,8 @@ def cloud_verify(
         )
 
     return CloudController().verify_cloud(
-        cloud_name=cloud_name or name, cloud_id=cloud_id, strict=strict
+        cloud_name=cloud_name or name,
+        cloud_id=cloud_id,
+        functional_verify=functional_verify,
+        strict=strict,
     )

anyscale-0.5.122/anyscale/commands/cluster_compute_commands.py → anyscale-0.5.123/anyscale/commands/compute_config_commands.py

@@ -2,7 +2,7 @@ from typing import IO, Optional
 
 import click
 
-from anyscale.controllers.cluster_compute_controller import ClusterComputeController
+from anyscale.controllers.compute_config_controller import ComputeConfigController
 from anyscale.util import validate_non_negative_arg
 from anyscale.utils.entity_arg_utils import format_inputs_to_entity
 
@@ -12,11 +12,11 @@ from anyscale.utils.entity_arg_utils import format_inputs_to_entity
     short_help="Manage compute configurations on Anyscale.",
     help="Manages compute configurations to define cloud resource types and limitations.",
 )
-def cluster_compute_cli() -> None:
+def compute_config_cli() -> None:
     pass
 
 
-@cluster_compute_cli.command(
+@compute_config_cli.command(
     name="create",
     help=(
         "Creates a new compute config. This accepts a yaml that follows the schema defined "
@@ -34,10 +34,10 @@ def cluster_compute_cli() -> None:
 def create_cluster_compute(
     cluster_compute_file: IO[bytes], name: Optional[str]
 ) -> None:
-    ClusterComputeController().create(cluster_compute_file, name)
+    ComputeConfigController().create(cluster_compute_file, name)
 
 
-@cluster_compute_cli.command(
+@compute_config_cli.command(
     name="delete", help="Delete the specified compute config.", hidden=True
 )
 @click.argument("cluster-compute-name", type=str, required=False)
@@ -64,10 +64,10 @@ def delete_cluster_compute(
         raise click.ClickException(
             "Please only provide one of [CLUSTER_COMPUTE_NAME] or --name."
         )
-    ClusterComputeController().delete(cluster_compute_name or name, cluster_compute_id)
+    ComputeConfigController().delete(cluster_compute_name or name, cluster_compute_id)
 
 
-@cluster_compute_cli.command(
+@compute_config_cli.command(
     name="archive", help="Archive the specified compute config.",
 )
 @click.argument("cluster-compute-name", type=str, required=False)
@@ -95,10 +95,10 @@ def archive_cluster_compute(
             "Please only provide one of [CLUSTER_COMPUTE_NAME] or --name."
         )
     entity = format_inputs_to_entity(cluster_compute_name or name, cluster_compute_id)
-    ClusterComputeController().archive(entity)
+    ComputeConfigController().archive(entity)
 
 
-@cluster_compute_cli.command(
+@compute_config_cli.command(
     name="list",
     help=(
         "List information about compute configs on Anyscale. By default only list "
@@ -139,7 +139,7 @@ def list(  # noqa: A001
     include_shared: bool,
     max_items: int,
 ) -> None:
-    cluster_compute_controller = ClusterComputeController()
+    cluster_compute_controller = ComputeConfigController()
     cluster_compute_controller.list(
         cluster_compute_name=name,
         cluster_compute_id=cluster_compute_id,
@@ -148,7 +148,7 @@ def list(  # noqa: A001
     )
 
 
-@cluster_compute_cli.command(
+@compute_config_cli.command(
     name="get", help=("Get details about compute configuration."),
 )
 @click.argument("cluster-compute-name", required=False)
@@ -160,7 +160,7 @@ def list(  # noqa: A001
     help=("Get details about compute configuration by this id."),
 )
 def get(cluster_compute_name: Optional[str], cluster_compute_id: Optional[str]) -> None:
-    cluster_compute_controller = ClusterComputeController()
+    cluster_compute_controller = ComputeConfigController()
     cluster_compute_controller.get(
         cluster_compute_name=cluster_compute_name,
         cluster_compute_id=cluster_compute_id,

{anyscale-0.5.122 → anyscale-0.5.123}/anyscale/controllers/cloud_controller.py

@@ -58,6 +58,9 @@ from anyscale.cloud_resource import (
 )
 from anyscale.conf import ANYSCALE_IAM_ROLE_NAME
 from anyscale.controllers.base_controller import BaseController
+from anyscale.controllers.cloud_functional_verification_controller import (
+    CloudFunctionalVerificationController,
+)
 from anyscale.formatters import clouds_formatter
 from anyscale.shared_anyscale_utils.aws import AwsRoleArn, get_dataplane_role_arn
 from anyscale.shared_anyscale_utils.conf import ANYSCALE_ENV
@@ -623,9 +626,11 @@ class CloudController(BaseController):
 
     def setup_managed_cloud(
         self,
+        *,
         provider: str,
         region: str,
         name: str,
+        functional_verify: Optional[str],
         cluster_management_stack_version: ClusterManagementStackVersions,
         project_id: str = None,
         _use_strict_iam_permissions: bool = False,  # This should only be used in testing.
@@ -633,6 +638,9 @@ class CloudController(BaseController):
         """
         Sets up a cloud provider
         """
+        functions_to_verify = self._validate_functional_verification_args(
+            functional_verify
+        )
         if provider == "aws":
             with self.log.spinner("Preparing environment for cloud setup..."):
                 (
@@ -746,6 +754,13 @@ class CloudController(BaseController):
                 f"Invalid Cloud provider: {provider}. Available providers are [aws, gcp]."
             )
 
+        if len(functions_to_verify) > 0:
+            CloudFunctionalVerificationController(self.log).start_verification(
+                cloud_id,
+                self._get_cloud_provider_from_str(provider),
+                functions_to_verify,
+            )
+
     def update_cloud_config(
         self,
         cloud_name: Optional[str],
@@ -1021,10 +1036,39 @@ class CloudController(BaseController):
     def _passed_or_failed_str_from_bool(self, is_passing: bool) -> str:
         return "PASSED" if is_passing else "FAILED"
 
-    def verify_cloud(
+    @staticmethod
+    def _get_cloud_provider_from_str(provider: str) -> CloudProviders:
+        if provider.lower() == "aws":
+            return CloudProviders.AWS
+        elif provider.lower() == "gcp":
+            return CloudProviders.GCP
+        else:
+            raise ClickException(
+                f"Unsupported provider {provider}. Supported providers are [aws, gcp]."
+            )
+
+    def _validate_functional_verification_args(
+        self, functional_verify: Optional[str]
+    ) -> List[str]:
+        if functional_verify is None:
+            return []
+        # validate functional_verify
+        supported_functions = "workspace"  # TODO (congding): add service
+        functions_to_verify = set()
+        for function in functional_verify.split(","):
+            if function.lower() not in supported_functions:
+                raise ClickException(
+                    f"Unsupported function {function} for --functional-verify. Supported functions are {list(supported_functions)}"
+                )
+            functions_to_verify.add(function.lower())
+        return list(functions_to_verify)
+
+    def verify_cloud(  # noqa: PLR0911
         self,
+        *,
         cloud_name: Optional[str],
         cloud_id: Optional[str],
+        functional_verify: Optional[str],
         boto3_session: Optional[Any] = None,
         strict: bool = False,
         _use_strict_iam_permissions: bool = False,  # This should only be used in testing.
@@ -1032,6 +1076,10 @@ class CloudController(BaseController):
         """
         Verifies a cloud by name or id.
         """
+        functions_to_verify = self._validate_functional_verification_args(
+            functional_verify
+        )
+
         cloud_id, cloud_name = get_cloud_id_and_name(
             self.api_client, cloud_id, cloud_name
         )
@@ -1056,7 +1104,7 @@ class CloudController(BaseController):
         if cloud.provider == "AWS":
             if boto3_session is None:
                 boto3_session = boto3.Session(region_name=cloud.region)
-            return self.verify_aws_cloud_resources(
+            if not self.verify_aws_cloud_resources(
                 cloud_resource=cloud_resource,
                 boto3_session=boto3_session,
                 region=cloud.region,
@@ -1067,23 +1115,32 @@ class CloudController(BaseController):
                 else False,
                 strict=strict,
                 _use_strict_iam_permissions=_use_strict_iam_permissions,
-            )
+            ):
+                return False
         elif cloud.provider == "GCP":
             project_id = json.loads(cloud.credentials)["project_id"]
-            return self.verify_gcp_cloud_resources(
+            if not self.verify_gcp_cloud_resources(
                 cloud_resource=cloud_resource,
                 project_id=project_id,
                 region=cloud.region,
                 cloud_id=cloud_id,
                 yes=False,
                 strict=strict,
-            )
+            ):
+                return False
         else:
             self.log.error(
                 f"This cloud {cloud_name}({cloud_id}) does not have a valid cloud provider."
             )
             return False
 
+        if len(functions_to_verify) == 0:
+            return True
+
+        return CloudFunctionalVerificationController(self.log).start_verification(
+            cloud_id, cloud.provider, functions_to_verify
+        )
+
     def verify_aws_cloud_resources(
         self,
         *,
@@ -1195,6 +1252,7 @@ class CloudController(BaseController):
 
     def register_aws_cloud(  # noqa: PLR0913
         self,
+        *,
         region: str,
         name: str,
         vpc_id: str,
@@ -1204,10 +1262,14 @@ class CloudController(BaseController):
         instance_iam_role_id: str,
         security_group_ids: List[str],
         s3_bucket_id: str,
+        functional_verify: Optional[str],
         private_network: bool,
         cluster_management_stack_version: ClusterManagementStackVersions,
         yes: bool = False,
     ):
+        functions_to_verify = self._validate_functional_verification_args(
+            functional_verify
+        )
         # Create a cloud without cloud resources first
         try:
             created_cloud = self.api_client.create_cloud_api_v2_clouds_post(
@@ -1302,6 +1364,11 @@ class CloudController(BaseController):
             f"Successfully created cloud {name}, id: {cloud_id}, and it's ready to use."
         )
 
+        if len(functions_to_verify) > 0:
+            CloudFunctionalVerificationController(self.log).start_verification(
+                cloud_id, CloudProviders.AWS, functions_to_verify
+            )
+
     def verify_gcp_cloud_resources(
         self,
         *,
@@ -1377,6 +1444,7 @@ class CloudController(BaseController):
 
     def register_gcp_cloud(  # noqa: PLR0913
         self,
+        *,
         region: str,
         name: str,
         project_id: str,
@@ -1389,10 +1457,14 @@ class CloudController(BaseController):
         provider_id: str,
         firewall_policy_names: List[str],
         cloud_storage_bucket_name: str,
+        functional_verify: Optional[str],
         private_network: bool,
         cluster_management_stack_version: ClusterManagementStackVersions,
         yes: bool = False,
     ):
+        functions_to_verify = self._validate_functional_verification_args(
+            functional_verify
+        )
         gcp_utils = try_import_gcp_utils()
 
         # Create a cloud without cloud resources first
@@ -1488,6 +1560,11 @@ class CloudController(BaseController):
             f"Successfully created cloud {name}, id: {cloud_id}, and it's ready to use."
         )
 
+        if len(functions_to_verify) > 0:
+            CloudFunctionalVerificationController(self.log).start_verification(
+                cloud_id, CloudProviders.GCP, functions_to_verify
+            )
+
     def delete_cloud(  # noqa: PLR0912
         self,
         cloud_name: Optional[str],

anyscale-0.5.123/anyscale/controllers/cloud_functional_verification_controller.py

@@ -0,0 +1,223 @@
+from datetime import datetime
+import time
+from typing import List, Optional
+
+from click import ClickException, confirm
+
+from anyscale.cli_logger import LogsLogger
+from anyscale.client.openapi_client.models.cloud_providers import CloudProviders
+from anyscale.client.openapi_client.models.create_experimental_workspace import (
+    CreateExperimentalWorkspace,
+)
+from anyscale.client.openapi_client.models.session_state import SessionState
+from anyscale.cluster_env import get_default_cluster_env_build
+from anyscale.controllers.base_controller import BaseController
+from anyscale.project import get_default_project
+from anyscale.sdk.anyscale_client.models.compute_node_type import ComputeNodeType
+from anyscale.sdk.anyscale_client.models.compute_template_query import (
+    ComputeTemplateQuery,
+)
+from anyscale.sdk.anyscale_client.models.create_cluster_compute import (
+    CreateClusterCompute,
+)
+from anyscale.sdk.anyscale_client.models.create_cluster_compute_config import (
+    CreateClusterComputeConfig,
+)
+from anyscale.util import get_endpoint
+
+
+POLL_INTERVAL_SECONDS = 10
+WORKSPACE_VERIFICATION_TIMEOUT_MINUTES = 10
+
+# default values for cluster compute config
+MAXIMUM_UPTIME_MINUTES = 15
+IDLE_TERMINATION_MINUTES = 5
+HEAD_NODE_TYPE_AWS = "m5.xlarge"
+HEAD_NODE_TYPE_GCP = "n1-standard-2"
+
+
+class CloudFunctionalVerificationController(BaseController):
+    def __init__(
+        self, log: Optional[LogsLogger] = None, initialize_auth_api_client: bool = True,
+    ):
+        if log is None:
+            log = LogsLogger()
+
+        super().__init__(initialize_auth_api_client=initialize_auth_api_client)
+        self.log = log
+
+    @staticmethod
+    def get_head_node_type(cloud_provider: CloudProviders) -> str:
+        """
+        Get the default head node type for the given cloud provider.
+        """
+        if cloud_provider == CloudProviders.AWS:
+            return HEAD_NODE_TYPE_AWS
+        elif cloud_provider == CloudProviders.GCP:
+            return HEAD_NODE_TYPE_GCP
+        raise ClickException(f"Unsupported cloud provider: {cloud_provider}")
+
+    def get_or_create_cluster_compute(
+        self, cloud_id: str, cloud_provider: CloudProviders
+    ) -> str:
+        """
+        Get or create a cluster compute for cloud functional verification
+        """
+        cluster_compute_name = f"functional_verification_{cloud_id}"
+
+        cluster_computes = self.api_client.search_compute_templates_api_v2_compute_templates_search_post(
+            ComputeTemplateQuery(
+                orgwide=True,
+                name={"equals": cluster_compute_name},
+                include_anonymous=True,
+            )
+        ).results
+        if len(cluster_computes) > 0:
+            return cluster_computes[0].id
+
+        head_node_instance_type = self.get_head_node_type(cloud_provider)
+        # no cluster compute found, create one
+        cluster_compute_config = CreateClusterComputeConfig(
+            cloud_id=cloud_id,
+            max_workers=0,
+            allowed_azs=["any"],
+            head_node_type=ComputeNodeType(
+                name="head_node_type", instance_type=head_node_instance_type,
+            ),
+            maximum_uptime_minutes=MAXIMUM_UPTIME_MINUTES,
+            idle_termination_minutes=IDLE_TERMINATION_MINUTES,
+            worker_node_types=[],
+        )
+        if cloud_provider == CloudProviders.AWS:
+            cluster_compute_config.aws_advanced_configurations_json = {
+                "TagSpecifications": [
+                    {
+                        "ResourceType": "instance",
+                        "Tags": [
+                            {"Key": "cloud_functional_verification", "Value": cloud_id,}
+                        ],
+                    }
+                ]
+            }
+        elif cloud_provider == CloudProviders.GCP:
+            cluster_compute_config.gcp_advanced_configurations_json = {
+                "instance_properties": {
+                    "labels": {"cloud_functional_verification": cloud_id},
+                }
+            }
+
+        cluster_compute = self.anyscale_api_client.create_cluster_compute(
+            CreateClusterCompute(
+                name=cluster_compute_name,
+                config=cluster_compute_config,
+                anonymous=True,
+            )
+        ).result
+        return cluster_compute.id
+
+    def verify_workspace(self, cloud_id: str, cloud_provider: CloudProviders) -> bool:
+        """
+        Verifies that the workspace is setup correctly on the given cloud
+        """
+        self.log.info("Starting workspace verification...")
+        confirm(
+            "Workspace verification will create a workspace on the cloud. \n"
+            f"This will spin up a {self.get_head_node_type(cloud_provider)} instance for about 5 to 10 minutes and will incur costs. \n"
+            "The workspace will be terminated after verification. Do you want to continue?",
+            abort=True,
+        )
+        try:
+            with self.log.spinner("Preparing to create workspace..."):
+                cluster_compute_id = self.get_or_create_cluster_compute(
+                    cloud_id, cloud_provider
+                )
+
+                cluster_env_build_id = get_default_cluster_env_build(
+                    self.api_client, self.anyscale_api_client
+                ).id
+
+                project_id = get_default_project(
+                    self.api_client, self.anyscale_api_client, parent_cloud_id=cloud_id
+                ).id
+        except ClickException as e:
+            self.log.error(f"Failed to prepare workspace: {e}")
+            return False
+
+        try:
+            with self.log.spinner("Creating workspace..."):
+
+                create_workspace_arg = CreateExperimentalWorkspace(
+                    name=f"workspace_functional_verification_{cloud_id}_{datetime.utcnow().strftime('%Y%m%d%H%M%S')}",
+                    description=f"workspace for cloud {cloud_id} functional verification",
+                    project_id=project_id,
+                    cloud_id=cloud_id,
+                    compute_config_id=cluster_compute_id,
+                    cluster_environment_build_id=cluster_env_build_id,
+                    idle_timeout_minutes=IDLE_TERMINATION_MINUTES,
+                )
+
+                workspace_response = self.api_client.create_workspace_api_v2_experimental_workspaces_post(
+                    create_workspace_arg
+                )
+        except ClickException as e:
+            self.log.error(f"Failed to create workspace: {e}")
+            return False
+
+        workspace_id = str(workspace_response.result.id)
+        cluster_id = str(workspace_response.result.cluster_id)
+        url = get_endpoint(f"/workspaces/{workspace_id}/{cluster_id}")
+        self.log.info(f"Workspace created at {url}")
+        verification_result = self.check_workspace_until_active(workspace_id, url)
+        if verification_result:
+            self.log.info("Workspace verification succeeded.")
+        else:
+            self.log.error(
+                f"Workspace verification failed. Please check errors at {url}"
+            )
+
+        # terminate workspace by terminating the cluster
+        try:
+            self.anyscale_api_client.terminate_cluster(cluster_id, {})
+        except ClickException as e:
+            # even if we fail to terminate the cluster, it will be terminated automatically with maximum uptime speicified
+            self.log.error(f"Failed to terminate workspace: {e}")
+        return verification_result
+
+    def check_workspace_until_active(self, workspace_id: str, url: str):
+        self.log.info(
+            "Note it may take about 5 to 10 minutes to create a workspace for the first time on a cloud."
+        )
+        with self.log.spinner("Waiting for workspace to be active..."):
+            start_time = time.time()
+            end_time = start_time + WORKSPACE_VERIFICATION_TIMEOUT_MINUTES * 60
+            while time.time() < end_time:
+                time.sleep(POLL_INTERVAL_SECONDS)
+                try:
+                    workspace = self.api_client.get_workspace_api_v2_experimental_workspaces_workspace_id_get(
+                        workspace_id
+                    ).result
+                except ClickException as e:
+                    self.log.error(f"Failed to get workspace status: {e}")
+                    return False
+                self.log.info(f"Workspace status: {workspace.state}")
+                if workspace.state == SessionState.RUNNING:
+                    return True
+        self.log.error(f"Timeout when creating workspace, please check errors at {url}")
+        return False
+
+    def start_verification(
+        self,
+        cloud_id: str,
+        cloud_provider: CloudProviders,
+        functions_to_verify: List[str],
+    ) -> bool:
+        # TODO (congding): parallelize the verification
+        # TODO (congding): add service
+        verification_results: List[bool] = []
+        for function in functions_to_verify:
+            if function == "workspace":
+                workspace_verification_result = self.verify_workspace(
+                    cloud_id, cloud_provider
+                )
+                verification_results.append(workspace_verification_result)
+        return all(verification_results)

anyscale-0.5.122/anyscale/controllers/cluster_compute_controller.py → anyscale-0.5.123/anyscale/controllers/compute_config_controller.py

@@ -136,7 +136,7 @@ class CreateClusterComputeConfigModel(BaseModel):
         allow_population_by_field_name = True
 
 
-class ClusterComputeController(BaseController):
+class ComputeConfigController(BaseController):
     """
     This controller powers functionalities related to Anyscale
     cluster compute configuration.

{anyscale-0.5.122 → anyscale-0.5.123}/anyscale/scripts.py

@@ -10,8 +10,8 @@ from anyscale.commands.anyscale_api.api_commands import anyscale_api
 from anyscale.commands.auth_commands import auth_cli
 from anyscale.commands.cloud_commands import cloud_cli
 from anyscale.commands.cluster_commands import cluster_cli
-from anyscale.commands.cluster_compute_commands import cluster_compute_cli
 from anyscale.commands.cluster_env_commands import cluster_env_cli
+from anyscale.commands.compute_config_commands import compute_config_cli
 from anyscale.commands.config_commands import config_cli
 from anyscale.commands.exec_commands import anyscale_exec
 from anyscale.commands.experimental_integrations_commands import (
@@ -28,6 +28,7 @@ from anyscale.commands.service_commands import service_cli
 from anyscale.commands.session_commands_hidden import session_cli
 from anyscale.commands.workspace_commands import workspace_cli
 import anyscale.conf
+from anyscale.utils.cli_version_check_util import log_warning_if_version_needs_upgrade
 
 
 logger = logging.getLogger(__name__)
@@ -74,6 +75,7 @@ class AliasedGroup(click.Group):
 def cli(ctx: Any, version_flag: bool, show_json: bool) -> None:
     if version_flag:
         ctx.invoke(version_cli, show_json=show_json)
+    log_warning_if_version_needs_upgrade()
 
 
 @click.command(name="version", help="Display version of the anyscale CLI.")
@@ -114,7 +116,7 @@ cli.add_command(auth_cli)
 cli.add_command(anyscale_init)
 cli.add_command(anyscale_exec)
 cli.add_command(anyscale_help)
-cli.add_command(cluster_compute_cli)
+cli.add_command(compute_config_cli)
 
 # Commands to interact with the Anyscale API
 cli.add_command(anyscale_api)
@@ -128,7 +130,7 @@ ALIASES = {
     "schedules": schedule_cli,
     "jobs": job_cli,
     "services": service_cli,
-    "cluster-compute": cluster_compute_cli,
+    "cluster-compute": compute_config_cli,
 }